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 org.apache.commons.lang3.StringUtils;

import org.gdal.ogr.DataSource;

import org.gdal.ogr.FeatureDefn;

import org.gdal.ogr.GeomFieldDefn;

import org.gdal.ogr.Layer;

import org.gdal.ogr.ogr;

import org.gvsig.fmap.dal.DALFileLibrary;

import org.gvsig.fmap.dal.DALFileLocator;

import org.gvsig.fmap.dal.DALLibrary;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.FileHelper;

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

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

import org.gvsig.metadata.MetadataLibrary;

import org.gvsig.metadata.exceptions.MetadataException;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dynobject.DynClass;

import org.gvsig.tools.dynobject.DynField;

import org.gvsig.tools.dynobject.DynField_v2;

import org.gvsig.tools.dynobject.DynField_v2.AvailableValuesProvider;

import org.gvsig.tools.dynobject.DynObject;

import org.gvsig.tools.dynobject.DynObjectManager;

import org.gvsig.tools.dynobject.DynObjectValueItem;

import org.gvsig.tools.library.AbstractLibrary;

import org.gvsig.tools.library.LibraryException;

import org.gvsig.tools.persistence.PersistenceManager;

/**

 * 

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

 *

 */

public class OGRLibrary extends AbstractLibrary {

    @Override

    public void doRegistration() {

        registerAsImplementationOf(OGRLibrary.class);

        require(DALLibrary.class);

        require(DALFileLibrary.class);

        require(MetadataLibrary.class);

    }

    @Override

    protected void doInitialize() throws LibraryException {

        // Register all drivers

        ogr.RegisterAll();

    }

    @Override

    protected void doPostInitialize() throws LibraryException {

        // Register OGR parameters definition

        FileHelper.registerParametersDefinition(OGRDataStoreParameters.PARAMETERS_DEFINITION_NAME,

            OGRDataStoreParameters.class, "OGRDataStoreParameters.xml");

        FileHelper.registerParametersDefinition(

            OGRNewDataStoreParameters.PARAMETERS_DEFINITION_NAME, OGRNewDataStoreParameters.class,

            "OGRNewDataStoreParameters.xml");

        FileHelper.registerParametersDefinition(

            OGRDataExplorerParameters.PARAMETERS_DEFINITION_NAME, OGRDataExplorerParameters.class,

            "OGRExplorerParameters.xml");

        // Register OGR metadata definition

        try {

            FileHelper.registerMetadataDefinition(OGRDataStoreProvider.METADATA_DEFINITION_NAME,

                OGRDataStoreProvider.class, "OGRMetadata.xml");

        } catch (MetadataException e) {

            throw new LibraryException(getClass(), e);

        }

        // Register OGR provider factory

        DataManagerProviderServices dataman =

            (DataManagerProviderServices) DALLocator.getDataManager();

        if (!dataman.getStoreProviders().contains(OGRDataStoreProvider.NAME)) {

            dataman.registerStoreProviderFactory(new BasicOGRDataStoreProviderFactory(

                OGRDataStoreProvider.NAME, OGRDataStoreProvider.DESCRIPTION));

        }

        // Register OGR data explorer provider

        if (!dataman.getExplorerProviders().contains(OGRDataExplorer.NAME)) {

            dataman.registerExplorerProvider(OGRDataExplorer.NAME, OGRDataExplorer.class,

                OGRDataExplorerParameters.class);

        }

        // Register OGR file system server provider

        DALFileLocator.getFilesystemServerExplorerManager().registerProvider(

            OGRDataStoreProvider.NAME, OGRDataStoreProvider.DESCRIPTION,

            OGRFilesystemServerProvider.class);

        DynObjectManager dynMan = ToolsLocator.getDynObjectManager();

        DynClass dynClass = dynMan.get(OGRDataStoreProvider.METADATA_DEFINITION_NAME);

        if (dynClass == null) {

            dynClass = dynMan.add(OGRDataStoreProvider.METADATA_DEFINITION_NAME);

        }

        // Register OGR resource provider

        ResourceManagerProviderServices resman =

            (ResourceManagerProviderServices) DALLocator.getResourceManager();

        if (!resman.getResourceProviders().contains(OGRResource.NAME)) {

            resman.register(OGRResource.NAME, OGRResource.DESCRIPTION, OGRResource.class,

                OGRResourceParameters.class);

        }

        // Register persistence definition of OGR resource parameters

        OGRResourceParameters.registerPersistenceDefinition();

        fixDataParameters();

    }

    private void fixDataParameters() {

        // XXX: This code is commented because until version of gvSIG tools at

        // gvSIG Desktop POM is greater or equal to 3.0.78. If the version is

        // greater or equals remove this comment and uncomment code.

        // DynObjectManager dynObjectManager =

        // ToolsLocator.getDynObjectManager();

        // DynClass dynClass =

        // dynObjectManager.get(PersistenceManager.PERSISTENCE_NAMESPACE,

        // OGRDataStoreParameters.PARAMETERS_DEFINITION_NAME);

        // DynField_v2 dynField = (DynField_v2)

        // dynClass.getDynField("defaultGeometryField");

        // dynField.setAvailableValuesProvider(new AvailableValuesProvider() {

        //

        // @Override

        // public DynObjectValueItem[] getValues(DynField field, DynObject

        // dynObject) {

        //

        // if (dynObject instanceof OGRDataStoreParameters) {

        //

        // DataSource dataSource = null;

        // try {

        // // Open connection string

        // OGRDataStoreParameters ogrParameters = (OGRDataStoreParameters)

        // dynObject;

        // if (StringUtils.isNotBlank(ogrParameters.getConnectionString())) {

        // dataSource = ogr.Open(ogrParameters.getConnectionString());

        // } else if (ogrParameters.getFile() != null

        // && ogrParameters.getFile().exists()) {

        // dataSource = ogr.Open(ogrParameters.getFile().getAbsolutePath());

        // }

        //

        // // Get layer

        // Layer layer = null;

        // if (StringUtils.isNotBlank(ogrParameters.getLayerName())) {

        // layer = dataSource.GetLayerByName(ogrParameters.getLayerName());

        // }

        //

        // // Get geometry fields

        // if (layer != null) {

        // FeatureDefn layerDefn = layer.GetLayerDefn();

        // DynObjectValueItem[] valueItems =

        // new DynObjectValueItem[layerDefn.GetGeomFieldCount()];

        // for (int i = 0; i < layerDefn.GetGeomFieldCount(); i++) {

        // GeomFieldDefn geomFieldDefn = layerDefn.GetGeomFieldDefn(i);

        // valueItems[i] = new DynObjectValueItem(geomFieldDefn.GetName());

        // }

        //

        // return valueItems;

        // }

        // } finally {

        // // Free native resources

        // dataSource.delete();

        // }

        // }

        // return null;

        // }

        //

        // });

    }

}

/**

 * 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.util.List;

import java.util.Vector;

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.spi.DataStoreProviderServices;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dynobject.DelegatedDynObject;

/**

 * 

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

 *

 */

public class OGRNewDataStoreParameters extends OGRDataStoreParameters implements

    NewFeatureStoreParameters {

    /**

     * 

     */

    public static final String PARAMETERS_DEFINITION_NAME = "OGRNewDataStoreParameters";

    /**

     * 

     */

    public static final String DRIVER_NAME_PARAMETER_NAME = "driverName";

    /**

     * 

     */

    public static final String DATASET_CREATION_OPTION_PARAMETER_NAME = "datasetCreationOptions";

    /**

     * 

     */

    public OGRNewDataStoreParameters() {

        parameters =

            (DelegatedDynObject) ToolsLocator.getDynObjectManager().createDynObject(

                ToolsLocator.getPersistenceManager().getDefinition(PARAMETERS_DEFINITION_NAME));

        this.setDynValue(DataStoreProviderServices.PROVIDER_PARAMTER_NAME,

            OGRDataStoreProvider.NAME);

    }

    @Override

    public void setDefaultFeatureType(FeatureType defaultFeatureType) {

        this.setDynValue(FEATURETYPE_PARAMTER_NAME, defaultFeatureType);

    }

    @Override

    public EditableFeatureType getDefaultFeatureType() {

        return (EditableFeatureType) this.getDynValue(FEATURETYPE_PARAMTER_NAME);

    }

    /**

     * @param driverName

     *            Sets driver that will be used to create new stores

     */

    public void setDriverName(String driverName) {

        this.setDynValue(DRIVER_NAME_PARAMETER_NAME, driverName);

    }

    /**

     * @return Name of driver to create new data stores

     */

    public String getDriverName() {

        return (String) this.getDynValue(DRIVER_NAME_PARAMETER_NAME);

    }

    /**

     * 

     * @param options

     *            Set dataset creation options

     */

    @SuppressWarnings("rawtypes")

    public void setDatasetCreationOptions(List options) {

        this.setDynValue(DATASET_CREATION_OPTION_PARAMETER_NAME, options);

    }

    /**

     * @return Dataset creation options

     */

    @SuppressWarnings("rawtypes")

    public List getDatasetCreationOptions() {

        return (Vector) this.getDynValue(DATASET_CREATION_OPTION_PARAMETER_NAME);

    }

}

/**

 * 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;

    }

}

/**

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

import java.util.Calendar;

import java.util.Date;

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

import org.gdal.ogr.FeatureDefn;

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.crs.CRSFactory;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataTypes;

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

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

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

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

import org.gvsig.fmap.dal.feature.spi.DefaultFeatureProvider;

import org.gvsig.fmap.dal.feature.spi.FeatureProvider;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.Geometry.SUBTYPES;

import org.gvsig.fmap.geom.Geometry.TYPES;

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.GeometryManager;

import org.gvsig.fmap.geom.operation.GeometryOperationException;

import org.gvsig.fmap.geom.operation.GeometryOperationNotSupportedException;

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

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

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

import org.gvsig.tools.exception.BaseException;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 * Converter class used to parse OGR layer defn, feature, types... to gvSIG

 * objects and constant.

 *

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

 *

 */

public class OGRConverter {

    /**

     * Default geometry column name used when the geometry column of layer does

     * not have name. This is necessary to create FeatureType and it must take

     * into account when feature geometry is requested.

     */

    private final String DEFAULT_GEOMETRY_COLUMN_NAME = "ogr_geometry";

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

    /**

     *

     */

    public OGRConverter() {

    }

    /**

     * Converts {@link FeatureDefn} to {@link FeatureType} and sets

     * default geometry field to created {@link FeatureType}.

     *

     * @param featureDefn

     *            OGR definition to be converted

     * @param defaultGeometryField

     *            Default geometry field. If it is not founded, this method will

     *            take the first geometry field.

     * @return FeatureType Feature type equivalent

     * @throws GeometryTypeNotSupportedException

     *             If there are problems parsing OGR geometry

     * @throws GeometryTypeNotValidException

     *             If type of OGR Geometry is not supported

     */

    public FeatureType convert(FeatureDefn featureDefn, String defaultGeometryField)

        throws GeometryTypeNotSupportedException, GeometryTypeNotValidException {

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

        editableFeatureType.setHasOID(true);

        for (int i = 0; i < featureDefn.GetFieldCount(); i++) {

            FieldDefn fieldDefn = featureDefn.GetFieldDefn(i);

            EditableFeatureAttributeDescriptor attributeDescriptor =

                editableFeatureType.add(fieldDefn.GetName(),

                    this.convertToDataType(fieldDefn.GetFieldType()));

            attributeDescriptor.setPrecision(fieldDefn.GetPrecision());

        }

        for (int i = 0; i < featureDefn.GetGeomFieldCount(); i++) {

            GeomFieldDefn geomFieldDefn = featureDefn.GetGeomFieldDefn(i);

            String name = null;

            if (StringUtils.isBlank(geomFieldDefn.GetName())) {

                // Set default geometry column name

                name = DEFAULT_GEOMETRY_COLUMN_NAME;

            } else {

                name = geomFieldDefn.GetName();

            }

            EditableFeatureAttributeDescriptor attributeDescriptor =

                editableFeatureType.add(name, DataTypes.GEOMETRY);

            // GDAL 1.11.2 Only supports 2D geometries

            GeometryManager geometryManager = GeometryLocator.getGeometryManager();

            GeometryType geometryType =

                geometryManager.getGeometryType(

                    this.convertToGeomType(geomFieldDefn.GetFieldType()), SUBTYPES.GEOM2D);

            attributeDescriptor.setGeometryType(geometryType);

            if (geomFieldDefn.GetSpatialRef() != null) {

                IProjection projection =

                    CRSFactory.getCRSFactory().get(ICRSFactory.FORMAT_WKT,

                        geomFieldDefn.GetSpatialRef().ExportToWkt());

                attributeDescriptor.setSRS(projection);

            }

        }

        if (editableFeatureType.getAttributeDescriptor(defaultGeometryField) != null) {

            editableFeatureType.setDefaultGeometryAttributeName(defaultGeometryField);

        } else {

            FeatureAttributeDescriptor[] attributeDescriptors =

                editableFeatureType.getAttributeDescriptors();

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

                if (attributeDescriptors[i].getDataType().getType() != DataTypes.GEOMETRY) {

                    continue;

                }

                if (attributeDescriptors[i].getGeomType().getType() == convertToGeomType(featureDefn

                    .GetGeomType())) {

                    editableFeatureType.setDefaultGeometryAttributeName(attributeDescriptors[i]

                        .getName());

                    LOG.warn(

                        "Default geometry field {} has not been found. Setting \"{}\" as default geometry field",

                        new Object[] { defaultGeometryField, attributeDescriptors[i].getName() });

                    break;

                }

            }

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

                LOG.warn("The default geometry field can not be set");

            }

        }

        return editableFeatureType.getNotEditableCopy();

    }

    /**

     * Converts {@link FeatureAttributeDescriptor} of {@link FeatureType} to

     * {@link FieldDefn}

     *

     * @param featureType

     *            Fields to be converted

     * @return FieldDefn list OGR fields

     */

    public List<FieldDefn> convertFields(FeatureType featureType) {

        List<FieldDefn> fields = new ArrayList<FieldDefn>();

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

            FeatureAttributeDescriptor attributeDescriptor = featureType.getAttributeDescriptor(i);

            if (attributeDescriptor.getType() != DataTypes.GEOMETRY) {

                fields.add(convertField(attributeDescriptor));

            }

        }

        return fields;

    }

    /**

     * Converts {@link FeatureAttributeDescriptor} to {@link FieldDefn}

     *

     * @param attDescriptor

     * @return FieldDefn

     */

    public FieldDefn convertField(FeatureAttributeDescriptor attDescriptor) {

        if (attDescriptor != null) {

            FieldDefn fieldDefn =

                new FieldDefn(attDescriptor.getName(), this.convertToOGRType(attDescriptor

                    .getType()));

            fieldDefn.SetPrecision(attDescriptor.getPrecision());

            return fieldDefn;

        }

        return null;

    }

    /**

     * Converts geometry {@link FeatureAttributeDescriptor} of

     * {@link FeatureType} to {@link GeomFieldDefn}

     *

     * @param featureType

     *            Geometry fields to be converted

     * @param convertDefaultGeometryColumn

     *            True if default geometry will be converted, otherwise default

     *            geometry field won't be converted.

     * @return GeomFieldDefn list OGR Geometry fields

     */

    public List<GeomFieldDefn> convertGeometryFields(FeatureType featureType,

        boolean convertDefaultGeometryColumn) {

        List<GeomFieldDefn> geometryFields = new ArrayList<GeomFieldDefn>();

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

            FeatureAttributeDescriptor attributeDescriptor = featureType.getAttributeDescriptor(i);

            if (attributeDescriptor.getType() == DataTypes.GEOMETRY) {

                // Check if default geometry column must be converted too

                if (i != featureType.getDefaultGeometryAttributeIndex()

                    || (i == featureType.getDefaultGeometryAttributeIndex() && convertDefaultGeometryColumn)) {

                    geometryFields.add(convertGeomField(attributeDescriptor));

                }

            }

        }

        return geometryFields;

    }

    /**

     * Converts {@link FeatureAttributeDescriptor} to {@link GeomFieldDefn}

     *

     * @param attDescriptor

     *            Attribute to be converted

     * @return GeomFieldDefn OGR Geometry field

     */

    public GeomFieldDefn convertGeomField(FeatureAttributeDescriptor attDescriptor) {

        String name = attDescriptor.getName();

        if (attDescriptor.getName().equals(DEFAULT_GEOMETRY_COLUMN_NAME)) {

            name = "";

        }

        GeomFieldDefn geomFieldDefn =

            new GeomFieldDefn(name,

                this.convertToOGRGeomType(attDescriptor.getGeomType().getType()));

        if (attDescriptor.getSRS() != null) {

            SpatialReference srs =

                new SpatialReference(attDescriptor.getSRS().export(ICRSFactory.FORMAT_WKT));

            geomFieldDefn.SetSpatialRef(srs);

        }

        return geomFieldDefn;

    }

    /**

     * Converts {@link Feature} to {@link FeatureProvider}. If

     * {@link FeatureProvider} is null, it will be instantiated. This method

     * only takes into account the fields of received {@link FeatureType}.

     *

     * @param featureProvider

     *

     * @param featureType

     *            Type of feature provider

     * @param ogrFeature

     *            OGR Feature to be converted

     * @return FeatureProvider

     *         FeatureProvder with OGR Feature values

     */

    public FeatureProvider convert(FeatureProvider featureProvider, FeatureType featureType,

        Feature ogrFeature) {

        int fid = ogrFeature.GetFID();

        if (featureProvider == null) {

            featureProvider = new DefaultFeatureProvider(featureType, fid);

        } else {

            featureProvider.setOID(fid);

        }

        FeatureDefn defnRef = ogrFeature.GetDefnRef();

        FeatureAttributeDescriptor[] attributeDescriptors = featureType.getAttributeDescriptors();

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

            if (attributeDescriptors[i].getDataType().getType() == DataTypes.GEOMETRY) {

                String name = attributeDescriptors[i].getName();

                org.gdal.ogr.Geometry ogrGeometry = null;

                int fieldIndex = -1;

                if (name.equals(DEFAULT_GEOMETRY_COLUMN_NAME)) {

                    // If geometry column name equals default column name,

                    // change it to empty string.

                    fieldIndex = defnRef.GetGeomFieldIndex("");

                } else {

                    fieldIndex = defnRef.GetGeomFieldIndex(name);

                }

                ogrGeometry = ogrFeature.GetGeomFieldRef(fieldIndex);

                if (ogrGeometry != null) {

                    Geometry geometry = null;

                    try {

                        geometry =

                            GeometryLocator.getGeometryManager().createFrom(

                                ogrGeometry.ExportToWkb());

                    } catch (BaseException e) {

                        LOG.warn(

                            String

                                .format(

                                    "Can not create geometry from %1s. Setting null value to geometry field",

                                    ogrGeometry.ExportToWkt()), e);

                        geometry = null;

                    }

                    if (attributeDescriptors[i].getName().equals(

                        featureType.getDefaultGeometryAttributeName())) {

                        featureProvider.setDefaultGeometry(geometry);

                    }

                    featureProvider.set(name, geometry);

                }

            } else {

                String name = attributeDescriptors[i].getName();

                int fieldIndex = defnRef.GetFieldIndex(name);

                FieldDefn fieldDefn = defnRef.GetFieldDefn(fieldIndex);

                int dataType = convertToDataType(fieldDefn.GetFieldType());

                Object value = null;

                if (dataType == DataTypes.INT) {

                    value = ogrFeature.GetFieldAsInteger(i);

                } else if (dataType == DataTypes.DOUBLE) {

                    value = ogrFeature.GetFieldAsDouble(i);

                } else {

                    value = ogrFeature.GetFieldAsString(i);

                }

                featureProvider.set(fieldDefn.GetName(), value);

            }

        }

        return featureProvider;

    }

    /**

     * Converts {@link FeatureProvider} to {@link Feature}.

     *

     * @param featureProvider

     *            Feature provider to be converted

     * @return Feature OGR Feature with feature provider values.

     * @throws GeometryOperationNotSupportedException

     *             If operation used to convert geometries is not supported

     * @throws GeometryOperationException

     *             If there are some problems converting geometries

     */

    public Feature convert(FeatureProvider featureProvider)

        throws GeometryOperationNotSupportedException, GeometryOperationException {

        if (featureProvider == null) {

            return null;

        }

        FeatureType featureType = featureProvider.getType();

        FeatureDefn featureDefn = new FeatureDefn();

        List<FieldDefn> fields = this.convertFields(featureType);

        for (FieldDefn fieldDefn : fields) {

            featureDefn.AddFieldDefn(fieldDefn);

        }

        List<GeomFieldDefn> geometryFields = this.convertGeometryFields(featureType, true);

        for (GeomFieldDefn geomFieldDefn : geometryFields) {

            featureDefn.AddGeomFieldDefn(geomFieldDefn);

        }

        Feature feature = new Feature(featureDefn);

        Integer oid = null;

        if (featureProvider.getOID() instanceof Integer) {

            oid = (Integer) featureProvider.getOID();

        } else if (featureProvider.getOID() instanceof Long) {

            oid = ((Long) featureProvider.getOID()).intValue();

        }

        feature.SetFID(oid);

        FeatureAttributeDescriptor[] attributeDescriptors = featureType.getAttributeDescriptors();

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

            Integer fieldIndex = null;

            if (attributeDescriptors[i].getType() == DataTypes.GEOMETRY

                && attributeDescriptors[i].getName().equals(DEFAULT_GEOMETRY_COLUMN_NAME)) {

                fieldIndex = featureDefn.GetGeomFieldIndex("");

            } else if (attributeDescriptors[i].getType() == DataTypes.GEOMETRY) {

                fieldIndex = featureDefn.GetGeomFieldIndex(attributeDescriptors[i].getName());

            } else {

                fieldIndex = featureDefn.GetFieldIndex(attributeDescriptors[i].getName());

            }

            Object value = featureProvider.get(i);

            if (value == null) {

                continue;

            }

            if (attributeDescriptors[i].getType() == DataTypes.STRING) {

                feature.SetField(fieldIndex, (String) value);

            } else if (attributeDescriptors[i].getType() == DataTypes.DOUBLE) {

                feature.SetField(fieldIndex, (Double) value);

            } else if (attributeDescriptors[i].getType() == DataTypes.BOOLEAN) {

                feature.SetField(fieldIndex, ((Boolean) value).toString());

            } else if (attributeDescriptors[i].getType() == DataTypes.DATE) {

                Date date = (Date) value;

                Calendar calendar = Calendar.getInstance();

                calendar.setTime(date);

                feature.SetField(i, calendar.get(Calendar.YEAR), calendar.get(Calendar.MONTH),

                    calendar.get(Calendar.DAY_OF_WEEK), calendar.get(Calendar.HOUR),

                    calendar.get(Calendar.MINUTE), calendar.get(Calendar.SECOND), 0);

            } else if (attributeDescriptors[i].getType() == DataTypes.GEOMETRY) {

                org.gvsig.fmap.geom.Geometry geometry = (Geometry) value;

                if (geometry != null) {

                    org.gdal.ogr.Geometry ogrGeometry = null;

                    if (attributeDescriptors[i].getSRS() != null) {

                        IProjection projection = attributeDescriptors[i].getSRS();

                        SpatialReference srs =

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

                        ogrGeometry = ogr.CreateGeometryFromWkt(geometry.convertToWKT(), srs);

                        feature.SetGeomField(i, ogrGeometry);

                    } else {

                        ogrGeometry = ogr.CreateGeometryFromWkt(geometry.convertToWKT());

                        feature.SetGeomField(fieldIndex, ogrGeometry);

                    }

                }

            }

        }

        return feature;

    }

    /**

     * Convert gvSIG geometry type to OGR geometry type. See

     * {@link ogrConstants}.

     *

     * @param type

     *            A type of {@link TYPES}

     * @return int Equivalent type of {@link ogrConstants}

     */

    public int convertToOGRGeomType(int type) {

        switch (type) {

        case TYPES.POINT:

            return ogrConstants.wkbPoint;

        case TYPES.CURVE:

        case TYPES.LINE:

        case TYPES.CIRCLE:

        case TYPES.ARC:

        case TYPES.ELLIPSE:

        case TYPES.SPLINE:

        case TYPES.ELLIPTICARC:

        case TYPES.CIRCUMFERENCE:

        case TYPES.PERIELLIPSE:

            return ogrConstants.wkbLineString;

        case TYPES.SURFACE:

        case TYPES.POLYGON:

        case TYPES.FILLEDSPLINE:

            return ogrConstants.wkbPolygon;

        case TYPES.AGGREGATE:

            return ogrConstants.wkbGeometryCollection;

        case TYPES.MULTIPOINT:

            return ogrConstants.wkbMultiPoint;

        case TYPES.MULTICURVE:

        case TYPES.MULTILINE:

            return ogrConstants.wkbMultiLineString;

        case TYPES.MULTISURFACE:

        case TYPES.MULTIPOLYGON:

            return ogrConstants.wkbMultiPolygon;

        case TYPES.NULL:

            return ogrConstants.wkbNone;

        case TYPES.GEOMETRY:

        case TYPES.MULTISOLID:

        case TYPES.SOLID:

        case TYPES.COMPLEX:

        default:

            return ogrConstants.wkbUnknown;

        }

    }

    /**

     * Convert OGR geometry type to gvSIG geometry type. See {@link TYPES}.

     *

     * @param type

     *            A type of {@link ogrConstants}

     * @return int Equivalent type of {@link TYPES}

     */

    public int convertToGeomType(int type) {

        switch (type) {

        case ogrConstants.wkbPoint:

            return TYPES.POINT;

        case ogrConstants.wkbLineString:

            return TYPES.CURVE;

        case ogrConstants.wkbPolygon:

            return TYPES.SURFACE;

        case ogrConstants.wkbGeometryCollection:

            return TYPES.AGGREGATE;

        case ogrConstants.wkbMultiPoint:

            return TYPES.MULTIPOINT;

        case ogrConstants.wkbMultiLineString:

            return TYPES.MULTILINE;

        case ogrConstants.wkbMultiPolygon:

            return TYPES.MULTISURFACE;

        case ogrConstants.wkbNone:

            return TYPES.NULL;

        case ogrConstants.wkbUnknown:

        default:

            return TYPES.GEOMETRY;

        }

    }

    /**

     * Convert gvSIG type to OGR type. See {@link ogrConstants}.

     *

     * @param type

     *            A type of {@link DataTypes}

     * @return int Equivalent type of {@link ogrConstants}

     */

    public int convertToOGRType(int type) {

        switch (type) {

        case DataTypes.DATE:

            return ogrConstants.OFTDate;

        case DataTypes.DOUBLE:

        case DataTypes.FLOAT:

            return ogrConstants.OFTReal;

        case DataTypes.STRING:

            return ogrConstants.OFTString;

        case DataTypes.CHAR:

            return ogrConstants.OFTString;

        case DataTypes.INT:

            return ogrConstants.OFTInteger;

        case DataTypes.LONG: // There is not LONG type support

        default:

            return ogrConstants.OFTString;

        }

    }

    /**

     * Convert OGR type to gvSIG type. See {@link DataTypes}.

     *

     * @param type

     *            A type of {@link ogrConstants}

     * @return int Equivalent type of {@link DataTypes}

     */

    public int convertToDataType(int type) {

        switch (type) {

        case ogrConstants.OFTDate:

            return DataTypes.DATE;

        case ogrConstants.OFTReal:

            return DataTypes.DOUBLE;

        case ogrConstants.OFTInteger:

            return DataTypes.INT;

        case ogrConstants.OFTTime:

            return DataTypes.TIME;

        case ogrConstants.OFTString:

        default:

            return DataTypes.STRING;

        }

    }

    /**

     * Convert OGR Feature to another OGR Feature. This method take into account

     * only {@link FeatureDefn} fields to create new feature. This method is

     * useful when OGR {@link Layer} is copied to new {@link DataSource}.

     *

     * @param layerDefn

     *            Definition of new feature

     * @param feature

     *            OGR feature to be converted

     * @return Fixed feature

     */

    public org.gdal.ogr.Feature convert(FeatureDefn layerDefn, org.gdal.ogr.Feature feature) {

        Feature newFeature = new Feature(layerDefn);

        for (int i = 0; i < feature.GetDefnRef().GetFieldCount(); i++) {

            FieldDefn fieldDefn = feature.GetDefnRef().GetFieldDefn(i);

            int fieldIndex = newFeature.GetDefnRef().GetFieldIndex(fieldDefn.GetName());

            if (fieldIndex != -1) {

                int fieldType = feature.GetDefnRef().GetFieldDefn(i).GetFieldType();

                switch (fieldType) {

                case ogrConstants.OFTDate:

                    int[] year = new int[1];

                    int[] month = new int[1];

                    int[] day = new int[1];

                    int[] hour = new int[1];

                    int[] minute = new int[1];

                    int[] second = new int[1];

                    int[] flags = new int[1];

                    feature.GetFieldAsDateTime(i, year, month, day, hour, minute, second, flags);

                    newFeature.SetField(i, year[0], month[0], day[0], hour[0], minute[0],

                        second[0], flags[0]);

                    break;

                case ogrConstants.OFTReal:

                    newFeature.SetField(i, feature.GetFieldAsDouble(i));

                    break;

                case ogrConstants.OFTInteger:

                    newFeature.SetField(i, feature.GetFieldAsInteger(i));

                    break;

                case ogrConstants.OFTString:

                default:

                    newFeature.SetField(i, feature.GetFieldAsString(i));

                    break;

                }

            }

        }

        for (int i = 0; i < feature.GetDefnRef().GetGeomFieldCount(); i++) {

            GeomFieldDefn geomFieldDefn = feature.GetDefnRef().GetGeomFieldDefn(i);

            int fieldIndex = newFeature.GetDefnRef().GetGeomFieldIndex(geomFieldDefn.GetName());

            if (fieldIndex != -1) {

                if (geomFieldDefn.GetFieldType() == newFeature.GetGeomFieldDefnRef(fieldIndex)

                    .GetFieldType()) {

                    org.gdal.ogr.Geometry geometry =

                        feature.GetGeomFieldRef(geomFieldDefn.GetName());

                    newFeature.SetGeomField(fieldIndex, geometry);

                } else {

                    LOG.warn(

                        "Ignoring geometry field. Can not fix {}. Geometry type is not equals",

                        geomFieldDefn.GetName());

                }

            }

        }

        return newFeature;

    }

}

/**

 * 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 org.gvsig.fmap.dal.exception.InitializeException;

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

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

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

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

/**

 * 

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

 *

 */

public class OGRResource extends AbstractResource {

    /**

     * 

     */

    public static final String NAME = "OGRResource";

    /**

     * 

     */

    public static final String DESCRIPTION = "Any resource that can be opened by OGR";

    /**

     * 

     * @param parameters

     *            Parameters to open this resource

     * @throws InitializeException

     *             If there is some error initializating this resource

     */

    public OGRResource(OGRResourceParameters parameters) throws InitializeException {

        super(parameters);

    }

    @Override

    public boolean isThis(ResourceParameters parameters) throws ResourceException {

        if (parameters instanceof OGRResourceParameters) {

            OGRResourceParameters thisParameters = (OGRResourceParameters) getParameters();

            OGRResourceParameters otherParameters = (OGRResourceParameters) parameters;

            if (thisParameters.getName().equals(otherParameters.getName()) && thisParameters

                .getConnectionString().equals(otherParameters.getConnectionString())) {

                return true;

            }

        }

        return false;

    }

    @Override

    public String getName() throws AccessResourceException {

        return ((OGRResourceParameters) getParameters()).getName();

    }

    @Override

    public Object get() throws AccessResourceException {

        return ((OGRResourceParameters) getParameters()).getConnectionString();

    }

}

/**

 * 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 org.gvsig.fmap.dal.feature.FeatureStoreProviderFactory;

import org.gvsig.tools.dynobject.DynObject;

/**

 * OGR Provider factory to create parameters to create specific server data

 * explorers and specific data store providers.

 * 

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

 *

 */

public interface OGRDataStoreProviderFactory extends FeatureStoreProviderFactory {

    /**

     * 

     * @return Name of driver used to open sources

     */

    public String getDriver();