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

import java.util.List;

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

import org.gvsig.fmap.dal.DataServerExplorerParameters;

import org.gvsig.fmap.dal.DataStoreParameters;

import org.gvsig.fmap.dal.NewDataStoreParameters;

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

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

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

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

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

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

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

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

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

import org.gvsig.tools.dynobject.DynField;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 * 

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

 *

 */

public class OGRDataExplorer extends AbstractDataServerExplorer implements DataServerExplorerProvider, ResourceConsumer {

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

    /**

     * 

     */

    public static final String NAME = "OGRDataExplorer";

    private DataServerExplorerProviderServices providerServives;

    protected OGRDataExplorerParameters parameters;

    private ResourceProvider resourceProvider;

    protected DataSource dataSource;

    protected Boolean updateSupport;

    private List<Layer> layerList;

    /**

     * @param parameters

     *            Parameters to open data explorer.

     * @param providerServices

     *            Available services

     * @throws InitializeException

     *             If there is some error initializing this store provider

     */

    public OGRDataExplorer(OGRDataExplorerParameters parameters,

        DataServerExplorerProviderServices providerServices) throws InitializeException {

        super(parameters, providerServices);

        this.providerServives = providerServices;

        this.parameters = parameters;

        getResourceProvider().addConsumer(this);

    }

    private ResourceProvider getResourceProvider() {

        if (this.resourceProvider == null) {

            ResourceManagerProviderServices manager =

                (ResourceManagerProviderServices) DALLocator.getResourceManager();

            if (StringUtils.isBlank(parameters.getConnectionString())) {

                try {

                    this.resourceProvider =

                        (FileResource) manager.createAddResource(FileResource.NAME,

                            new Object[] { this.parameters.getFile().getAbsolutePath() });

                } catch (InitializeException e) {

                    throw new ReadRuntimeException(getProviderName(), e);

                }

            } else {

                try {

                    this.resourceProvider =

                        (OGRResource) manager.createAddResource(OGRResource.NAME,

                            new Object[] { this.parameters.getConnectionString() });

                } catch (InitializeException e) {

                    throw new ReadRuntimeException(getProviderName(), e);

                }

            }

        }

        return this.resourceProvider;

    }

    protected synchronized DataSource getDataSource() throws OGRUnsupportedFormatException {

        if (this.dataSource == null) {

            // Prioritize connection string over file

            if (StringUtils.isNotBlank(this.parameters.getConnectionString())) {

                // Trying to open in update mode

                this.dataSource = ogr.Open(this.parameters.getConnectionString(), 1);

                if (this.dataSource == null) {

                    this.dataSource = ogr.Open(this.parameters.getConnectionString());

                    updateSupport = false;

                } else {

                    updateSupport = true;

                }

            } else if (this.parameters.getFile() != null && this.parameters.getFile().exists()) {

                // Trying to open in update mode

                this.dataSource = ogr.Open(this.parameters.getFile().getAbsolutePath(), 1);

                if (this.dataSource == null) {

                    this.dataSource = ogr.Open(this.parameters.getFile().getAbsolutePath());

                    updateSupport = false;

                } else {

                    updateSupport = true;

                }

            } else {

                throw new IllegalStateException(

                    "Invalid parameters. Connection string must not be blank or file must exists");

            }

        }

        if (this.dataSource == null) {

            if (StringUtils.isNotBlank(this.parameters.getConnectionString())) {

                throw new OGRUnsupportedFormatException(this.parameters.getConnectionString());

            }

        }

        return this.dataSource;

    }

    @SuppressWarnings("unchecked")

    protected List<Layer> getLayerList() {

        if (this.layerList == null) {

            this.layerList = (List<Layer>) getResourceProvider().execute(new ResourceAction() {

                @Override

                public Object run() throws Exception {

                    List<Layer> layers = new ArrayList<Layer>();

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

                        layers.add(getDataSource().GetLayer(i));

                    }

                    return layers;

                }

            });

        }

        return this.layerList;

    }

    private Boolean hasUpdateSupport() throws OGRUnsupportedFormatException {

        if (this.updateSupport == null) {

            // Open data source to check update support of driver

            getDataSource();

        }

        return this.updateSupport;

    }

    @Override

    public String getProviderName() {

        return NAME;

    }

    @Override

    public boolean canAdd() {

        return (boolean) getResourceProvider().execute(new ResourceAction() {

            @Override

            public Object run() throws Exception {

                return getDataSource().TestCapability(ogrConstants.ODsCCreateLayer)

                    && getDataSource().TestCapability(ogrConstants.ODsCDeleteLayer)

                    && hasUpdateSupport();

            }

        });

    }

    @Override

    public boolean canAdd(String storeName) throws DataException {

        return getDataStoreProviderNames().contains(storeName) && canAdd();

    }

    @SuppressWarnings("rawtypes")

    @Override

    public List list() throws DataException {

        return list(MODE_ALL);

    }

    @SuppressWarnings("rawtypes")

    @Override

    public List list(int mode) throws DataException {

        List<Layer> layerList = getLayerList();

        DataManager dataManager = DALLocator.getDataManager();

        List<OGRDataStoreParameters> parametersList = new ArrayList<OGRDataStoreParameters>();

        for (Layer layer : layerList) {

            OGRDataStoreParameters storeParameters =

                (OGRDataStoreParameters) dataManager.createStoreParameters(OGRDataStoreProvider.NAME);

            String connectionString = this.parameters.getConnectionString();

            File file = this.parameters.getFile();

            storeParameters.setConnectionString(connectionString);

            storeParameters.setFile(file);

            storeParameters.setLayerName(layer.GetName());

            parametersList.add(storeParameters);

        }

        return parametersList;

    }

    @Override

    public boolean add(String provider, final NewDataStoreParameters parameters,

        final boolean overwrite) throws DataException {

        if (canAdd()) {

            return (boolean) getResourceProvider().execute(new ResourceAction() {

                @Override

                public Object run() throws Exception {

                    if (parameters instanceof OGRNewDataStoreParameters) {

                        OGRNewDataStoreParameters ogrParameters =

                            (OGRNewDataStoreParameters) parameters;

                        String layerName = ogrParameters.getLayerName();

                        if (overwrite) {

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

                                if (getLayerList().get(i).GetName().equals(layerName)) {

                                    getDataSource().DeleteLayer(i);

                                }

                            }

                        } else {

                            for (Layer layer : getLayerList()) {

                                if (layer.GetName().equals(layerName)) {

                                    return false;

                                }

                            }

                        }

                        EditableFeatureType editableFeatureType =

                            ogrParameters.getDefaultFeatureType();

                        OGRConverter converter = new OGRConverter();

                        // If SRS is defined convert it to spatial reference

                        IProjection projection = editableFeatureType.getDefaultSRS();

                        SpatialReference srs = null;

                        if (projection != null) {

                            srs = new SpatialReference(projection.export(ICRSFactory.FORMAT_PROJ4));

                        }

                        // Convert to geometry type to OGR Geometry type

                        Integer ogrGeometryType = null;

                        if (editableFeatureType.getDefaultGeometryAttribute() != null) {

                            int geomType =

                                editableFeatureType.getDefaultGeometryAttribute().getGeomType()

                                    .getType();

                            ogrGeometryType = converter.convertToOGRGeomType(geomType);

                        }

                        // Create layer

                        Layer newlayer = null;

                        if (srs == null) {

                            newlayer = getDataSource().CreateLayer(layerName);

                        } else if (ogrGeometryType == null && srs != null) {

                            newlayer = getDataSource().CreateLayer(layerName, srs);

                        } else if (ogrGeometryType != null && srs != null) {

                            newlayer = getDataSource().CreateLayer(layerName, srs, ogrGeometryType);

                        }

                        List<FieldDefn> fields =

                            converter.convertFields(editableFeatureType.getNotEditableCopy());

                        for (FieldDefn fieldDefn : fields) {

                            newlayer.CreateField(fieldDefn);

                        }

                        List<GeomFieldDefn> geometryFields =

                            converter.convertGeometryFields(

                                editableFeatureType.getNotEditableCopy(), false);

                        for (GeomFieldDefn geomFieldDefn : geometryFields) {

                            newlayer.CreateGeomField(geomFieldDefn);

                        }

                        return true;

                    }

                    return false;

                }

            });

        }

        return false;

    }

    @Override

    public void remove(final DataStoreParameters parameters) throws DataException {

        if (canAdd()) {

            getResourceProvider().execute(new ResourceAction() {

                @Override

                public Object run() throws Exception {

                    if (parameters instanceof OGRNewDataStoreParameters) {

                        OGRNewDataStoreParameters ogrParameters =

                            (OGRNewDataStoreParameters) parameters;

                        String layerName = ogrParameters.getLayerName();

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

                            if (getLayerList().get(i).GetName().equals(layerName)) {

                                getDataSource().DeleteLayer(i);

                                return true;

                            }

                        }

                    }

                    return false;

                }

            });

        }

    }

    @Override

    public NewDataStoreParameters getAddParameters(String storeName) throws DataException {

        if (getDataStoreProviderNames().contains(storeName)) {

            OGRNewDataStoreParameters newParameters = new OGRNewDataStoreParameters();

            newParameters.setFile(this.parameters.getFile());

            newParameters.setConnectionString(this.parameters.getConnectionString());

            return newParameters;

        }

        return null;

    }

    @Override

    public DataServerExplorerParameters getParameters() {

        return parameters;

    }

    @SuppressWarnings("rawtypes")

    @Override

    public List getDataStoreProviderNames() {

        List<String> providerNames = new ArrayList<String>();

        providerNames.add(OGRDataStoreProvider.NAME);

        return providerNames;

    }

    @Override

    public void doDispose() {

        try {

            getDataSource().SyncToDisk();

            getDataSource().delete();

        } catch (OGRUnsupportedFormatException e) {

            LOG.warn("Can not dispose OGRDataExplorer", e);

        }

        this.dataSource = null;

        this.layerList = null;

        getResourceProvider().removeConsumer(this);

        this.resourceProvider = null;

    }

    @Override

    public DataServerExplorerProviderServices getServerExplorerProviderServices() {

        return providerServives;

    }

    @Override

    public boolean closeResourceRequested(ResourceProvider resource) {

        try {

            getDataSource().SyncToDisk();

            getDataSource().delete();

        } catch (OGRUnsupportedFormatException e) {

            LOG.warn(String.format("Can not close requested resource %1s", resource), e);

        }

        this.dataSource = null;

        this.layerList = null;

        return true;

    }

    @Override

    public void resourceChanged(ResourceProvider resource) {

        try {

            getDataSource().SyncToDisk();

            getDataSource().delete();

        } catch (OGRUnsupportedFormatException e) {

            LOG.warn("Can not sync to disk or release native resources to reopen data source", e);

        }

        this.dataSource = null;

        this.layerList = null;

    }

    @Override

    public DataStoreParameters get(String name) throws DataException {

        // "name" es un nombre de fichero sin path.

        // No tengo nada clara esta implementacion

        OGRDataStoreParameters params = new OGRDataStoreParameters();

        //

        // Copiamos los paramametros que se llamen igual entre el explorer y

        // el DataStoreParametes

        for( DynField field : params.getDynClass().getDynFields() ) {

            String fieldName = field.getName();

            if( parameters.hasDynValue(fieldName) ) {

                params.setDynValue(fieldName, parameters.getDynValue(fieldName));

            }

        }

        // Si el file es una carpeta asignamos como file el fichero name que haya

        // en ella

        // Si el file es un fichero cogemos el fichero name que se encuentre en

        // su misma carpeta.

        if( parameters.getFile().isDirectory() ) {

            params.setFile(new File(parameters.getFile(),name));

        } else {

            params.setFile(new File(parameters.getFile().getParentFile(),name));

        }

        // Usamos como layer el nombre del fichero pasado como parametro.

        params.setLayerName(name);

        return params;

    }

}