Application: gvSIG desktop » gvSIG data providers based on gdal

<?xml version="1.0"?>

<definitions>

	<version>1.0.0</version>

	<classes>

		<class name="OGRDataExplorerParameters">

			<description>Store the parameters needed to create OGR data explorers

			</description>

			<fields>

				<field name="file" type="file" mandatory="false" group="Basic">

					<description>Resource file</description>

				</field>

				<field name="connectionString" type="string" mandatory="false"

					group="Basic">

					<description>Connection string to open data source</description>

				</field>

			</fields>

		</class>

	</classes>

</definitions>

<definitions>

	<version>1.0.0</version>

	<classes>

		<class name="OGRNewDataStoreParameters">

			<description>Store the parameters needed to create OGR data stores

			</description>

			<extends>

				<class namespace="dal" name="NewProviderParameters" />

				<class>OGRDataStoreParameters</class>

			</extends>

			<fields>

				<field name="driverName" type="string" mandatory="false" group="Basic">

					<description>Name of driver</description>

				</field>

				<field name="datasetCreationOptions" type="List" mandatory="false" group="Basic">

					<description>Name of driver</description>

				</field>

			</fields>

		</class>

	</classes>

</definitions>

<?xml version="1.0"?>

<definitions>

	<version>1.0.0</version>

	<classes>

		<class name="OGRDataStoreParameters">

			<extends>

				<class namespace="dal" name="ProviderParameters" />

			</extends>

			<description>Store the parameters needed to open OGR stores

			</description>

			<fields>

				<field name="CRS" type="crs" mandatory="false" group="Basic">

					<description>Coordinate reference system used</description>

				</field>

				<field name="file" type="file" mandatory="false" group="Basic">

					<description>Resource file</description>

				</field>

				<field name="connectionString" type="string" mandatory="false"

					group="Basic">

					<description>Connection string to open data source</description>

				</field>

				<field name="layerName" type="string" mandatory="false" group="Basic">

					<description>Layer name of data source</description>

				</field>

				<field name="defaultGeometryField" type="string" mandatory="false"

					group="Basic">

					<description>Name of default geometry field</description>

				</field>

			</fields>

		</class>

	</classes>

</definitions>  

<?xml version="1.0"?>

<!--

Definitions of metadata fields of a shp file.  

 -->

<definitions>

  <version>1.0.0</version>

  <classes>

    <class name="OGRDataStoreProvider" namespace="Metadata">

      <extends>

      	<class namespace="Metadata" name="SpatialProvider"/>

      </extends>

      <description>Metadata of a OGR provider</description>

      <fields>

      </fields>

    </class>

  </classes>

</definitions>  

org.gvsig.gdal.prov.ogr.OGRLibrary

/**

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

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

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dynobject.DelegatedDynObject;

/**

 * 

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

 *

 */

public class OGRDataExplorerParameters extends AbstractDataParameters

    implements DataServerExplorerParameters {

    /**

     * 

     */

    public static final String PARAMETERS_DEFINITION_NAME = "OGRDataExplorerParameters";

    /**

     * 

     */

    public static final String FILE_PARAMETER_NAME = "file";

    /**

     * 

     */

    public static final String CONNECTION_STRING_PARAMETER_NAME = "connectionString";

    private DelegatedDynObject parameters;

    /**

     * 

     */

    public OGRDataExplorerParameters() {

        this.parameters = (DelegatedDynObject) ToolsLocator.getDynObjectManager().createDynObject(

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

    }

    @Override

    public String getExplorerName() {

        return OGRDataExplorer.NAME;

    }

    @Override

    protected DelegatedDynObject getDelegatedDynObject() {

        return this.parameters;

    }

    /**

     * 

     * @return File

     */

    public File getFile() {

        return (File) this.getDynValue(FILE_PARAMETER_NAME);

    }

    /**

     * 

     * @return String

     */

    public String getConnectionString() {

        return (String) this.getDynValue(CONNECTION_STRING_PARAMETER_NAME);

    }

    /**

     * 

     * @param file

     *            File

     */

    public void setFile(File file) {

        this.setDynValue(FILE_PARAMETER_NAME, file);

    }

    /**

     * 

     * @param connection

     *            Connection string

     */

    public void setConnectionString(String connection) {

        this.setDynValue(CONNECTION_STRING_PARAMETER_NAME, connection);

    }

}

/**

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

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

/**

 * 

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

 *

 */

@SuppressWarnings("unchecked")

public class OGRUnsupportedFormatException extends DataException {

    private static final long serialVersionUID = -2670314598211236837L;

    private final static String MESSAGE =

        "Unsupported vectorial format. There are not any OGR driver registered to open %(connectionString)";

    private final static String KEY = "_UnsupportedVectorialFormatException";

    /**

     * @param messageFormat

     *            Message format

     * @param cause

     *            Cause

     * @param messageKey

     *            Message key

     * @param code

     *            code

     * @param values

     *            Values

     */

    public OGRUnsupportedFormatException(String messageFormat, Throwable cause, String messageKey,

        long code, Map<Object, Object> values) {

        super(messageFormat, cause, messageKey, code);

        this.values.putAll(values);

    }

    /**

     * @param messageFormat

     *            Message format

     * @param cause

     *            Cause

     * @param values

     *            Values

     */

    public OGRUnsupportedFormatException(String messageFormat, Throwable cause,

        Map<Object, Object> values) {

        super(messageFormat, cause, KEY, serialVersionUID);

        this.values.putAll(values);

    }

    /**

     * @param connectionString

     *            Conenction string

     */

    public OGRUnsupportedFormatException(String connectionString) {

        super(MESSAGE, KEY, serialVersionUID);

        this.values.put("connectionString", connectionString);

    }

}

/**

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

import java.util.List;

import org.apache.commons.lang3.StringUtils;

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

import org.gdal.ogr.Layer;

import org.gdal.ogr.ogr;

import org.gdal.ogr.ogrConstants;

import org.gvsig.fmap.dal.DataStore;

import org.gvsig.fmap.dal.DataStoreParameters;

import org.gvsig.fmap.dal.DataTypes;

import org.gvsig.fmap.dal.FileHelper;

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

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

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

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

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

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

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

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

import org.gvsig.fmap.dal.feature.FeatureQueryOrder.FeatureQueryOrderMember;

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

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

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

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

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

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

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

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

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

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

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.primitive.Envelope;

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

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

import org.gvsig.tools.dynobject.DynObject;

import org.gvsig.tools.evaluator.Evaluator;

import org.gvsig.tools.exception.BaseException;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 * 

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

 *

 */

public class OGRDataStoreProvider extends AbstractFeatureStoreProvider implements

    FeatureStoreProvider, ResourceConsumer {

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

    /**

     * 

     */

    public static final String METADATA_DEFINITION_NAME = "OGRDataStoreProvider";

    /**

     * 

     */

    public static final String NAME = "OGRDataStoreProvider";

    /**

     * 

     */

    public static final String DESCRIPTION = "OGR provider to open vectorial resources";

    protected DataSource dataSource;

    private Envelope envelope;

    private Layer newLayer;

    protected ResourceProvider resourceProvider;

    private Boolean updateSupport;

    private boolean opened = false;

    protected OGRDataStoreProvider(DataStoreParameters dataParameters,

        DataStoreProviderServices storeServices, DynObject metadata) throws InitializeException {

        super(dataParameters, storeServices, metadata);

        // Set CRS parameter to metadata

        this.setDynValue(DataStore.METADATA_CRS, dataParameters.getDynValue(DataStore.METADATA_CRS));

        getResource().addConsumer(this);

        try {

            this.open();

        } catch (OpenException e) {

            throw new InitializeException(NAME, e);

        }

    }

    protected OGRDataStoreProvider(DataStoreParameters dataParameters,

        DataStoreProviderServices storeServices) throws InitializeException {

        this(dataParameters, storeServices, FileHelper

            .newMetadataContainer(METADATA_DEFINITION_NAME));

    }

    /*

     * Lazy initialization of data source

     */

    protected synchronized DataSource getDataSource() throws OGRUnsupportedFormatException {

        if (this.dataSource == null) {

            // Prioritize connection string over file

            if (StringUtils.isNotBlank(getOGRParameters().getConnectionString())) {

                // Trying to open in update mode

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

                if (this.dataSource == null) {

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

                    updateSupport = false;

                } else {

                    updateSupport = true;

                }

            } else if (getOGRParameters().getFile() != null

                && getOGRParameters().getFile().exists()) {

                // Trying to open in update mode

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

                if (this.dataSource == null) {

                    this.dataSource = ogr.Open(getOGRParameters().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(getOGRParameters().getConnectionString())) {

                throw new OGRUnsupportedFormatException(getOGRParameters().getConnectionString());

            }

        }

        return this.dataSource;

    }

    /*

     * Lazy initialization of update support flag

     */

    private Boolean hasUpdateSupport() throws OGRUnsupportedFormatException {

        if (this.updateSupport == null) {

            getDataSource();

        }

        return this.updateSupport;

    }

    /*

     * Lazy initialization of layer

     */

    protected Layer getLayer() throws OGRUnsupportedFormatException {

        if (this.newLayer == null) {

            this.newLayer = getDataSource().GetLayer(getOGRParameters().getLayerName());

            // this.layer = getDataSource().GetLayer(0);

            if (this.newLayer == null) {

                LOG.warn("Can not get layer with {} name. Get first layer of data source",

                    getOGRParameters().getLayerName());

                this.newLayer = getDataSource().GetLayer(0);

                getOGRParameters().setLayerName(this.newLayer.GetName());

            }

        }

        return this.newLayer;

    }

    /*

     * Lazy envelope initialization

     */

    @Override

    public Envelope getEnvelope() throws DataException {

        open();

        if (this.envelope == null) {

            this.envelope = (Envelope) getResource().execute(new ResourceAction() {

                @Override

                public Object run() throws Exception {

                    double[] extent = getLayer().GetExtent(true);

                    if (extent != null) {

                        return GeometryLocator.getGeometryManager().createEnvelope(extent[0],

                            extent[2], extent[1], extent[3], SUBTYPES.GEOM2D);

                    } else {

                        Envelope tmpEnvelope =

                            GeometryLocator.getGeometryManager().createEnvelope(SUBTYPES.GEOM2D);

                        FeatureType featureType = getStoreServices().getDefaultFeatureType();

                        int index = 0;

                        while (index < getLayer().GetFeatureCount()) {

                            double[] envelope = new double[4];

                            Feature feature = getLayer().GetNextFeature();

                            int geomFieldIndex =

                                getLayer().GetLayerDefn().GetGeomFieldIndex(

                                    featureType.getDefaultGeometryAttributeName());

                            Geometry ogrGeometry = feature.GetGeomFieldRef(geomFieldIndex);

                            ogrGeometry.GetEnvelope(envelope);

                            tmpEnvelope.add(GeometryLocator.getGeometryManager()

                                .createEnvelope(envelope[0], envelope[2], envelope[1], envelope[3],

                                    SUBTYPES.GEOM2D));

                            index++;

                        }

                        return tmpEnvelope;

                    }

                }

            });

        }

        return this.envelope;

    }

    @Override

    public String getFullName() {

        StringBuilder stb = new StringBuilder();

        stb.append(NAME);

        stb.append(":");

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

            stb.append(getOGRParameters().getFile().getAbsolutePath());

            stb.append(":");

            stb.append(getOGRParameters().getLayerName());

        } else {

            stb.append(getOGRParameters().getConnectionString());

        }

        return stb.toString();

    }

    @Override

    public String getName() {

        return getOGRParameters().getLayerName();

    }

    @Override

    public String getProviderName() {

        return NAME;

    }

    @Override

    public boolean allowWrite() {

        try {

            return getLayer().TestCapability(ogrConstants.OLCAlterFieldDefn)

                && getLayer().TestCapability(ogrConstants.OLCCreateField)

                && getLayer().TestCapability(ogrConstants.OLCDeleteField)

                && getLayer().TestCapability(ogrConstants.OLCDeleteFeature) && hasUpdateSupport();

        } catch (OGRUnsupportedFormatException e) {

            LOG.error("Can not determinate if data source allows write", e);

            return false;

        }

    }

    @Override

    public ResourceProvider getResource() {

        if (this.resourceProvider == null) {

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

                try {

                    this.resourceProvider =

                        this.createResource(FileResource.NAME, new Object[] { getOGRParameters()

                            .getFile().getAbsolutePath() });

                } catch (InitializeException e) {

                    throw new ReadRuntimeException(String.format(

                        "Can not create file resource with %1s path", getOGRParameters().getFile()

                            .getAbsolutePath()), e);

                }

            } else {

                try {

                    this.resourceProvider =

                        this.createResource(OGRResource.NAME, new Object[] { getOGRParameters()

                            .getConnectionString() });

                } catch (InitializeException e) {

                    throw new ReadRuntimeException(String.format(

                        "Can not create OGR resource with %1s", getOGRParameters()

                            .getConnectionString()), e);

                }

            }

        }

        return resourceProvider;

    }

    @Override

    public Object getSourceId() {

        return this.getOGRParameters().getFile();

    }

    @Override

    public void open() throws OpenException {

        if (opened == false) {

            try {

                this.opened = loadFeatureType();

            } catch (BaseException e) {

                LOG.error("Can not load feature type", e);

                throw new OpenException(getFullName(), e);

            }

        }

    }

    protected boolean loadFeatureType() throws OGRUnsupportedFormatException,

        GeometryTypeNotSupportedException, GeometryTypeNotValidException {

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

            @Override

            public Object run() throws Exception {

                FeatureDefn featureDefn = getLayer().GetLayerDefn();

                OGRConverter converter = new OGRConverter();

                String defaultGeometryField = getOGRParameters().getDefaultGeometryField();

                FeatureType featureType = converter.convert(featureDefn, defaultGeometryField);

                if (featureType.getDefaultSRS() != null) {

                    setDynValue(DataStore.METADATA_CRS, featureType.getDefaultSRS());

                }

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

                featureTypes.add(featureType);

                getStoreServices().setFeatureTypes(featureTypes, featureType);

                return true;

            }

        });

    }

    @SuppressWarnings("rawtypes")

    @Override

    public void performChanges(final Iterator deleteds, final Iterator inserteds,

        final Iterator updateds, final Iterator featureTypesChanged) throws DataException {

        getResource().execute(new ResourceAction() {

            @Override

            public Object run() throws Exception {

                OGRConverter converter = new OGRConverter();

                if (getLayer().TestCapability(ogrConstants.OLCTransactions)) {

                    getLayer().StartTransaction();

                }

                while (featureTypesChanged.hasNext()) {

                    FeatureTypeChanged featureTypeChange =

                        (FeatureTypeChanged) featureTypesChanged.next();

                    FeatureType source = featureTypeChange.getSource();

                    FeatureType target = featureTypeChange.getTarget();

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

                        EditableFeatureAttributeDescriptor eAttDescriptor =

                            source.getEditable().getEditableAttributeDescriptor(i);

                        if (eAttDescriptor.getOriginalName() != null) {

                            int index =

                                getLayer().GetLayerDefn().GetFieldIndex(

                                    eAttDescriptor.getOriginalName());

                            FieldDefn field = converter.convertField(eAttDescriptor);

                            getLayer().AlterFieldDefn(index, field, ogrConstants.ALTER_ALL_FLAG);

                        } else if (target.getAttributeDescriptor(eAttDescriptor.getName()) == null) {

                            int index = getLayer().FindFieldIndex(eAttDescriptor.getName(), 1);

                            getLayer().DeleteField(index);

                        }

                    }

                    List<FieldDefn> fields = converter.convertFields(target);

                    for (FieldDefn fieldDefn : fields) {

                        int index = getLayer().GetLayerDefn().GetFieldIndex(fieldDefn.GetName());

                        if (index == -1) {

                            getLayer().CreateField(fieldDefn);

                        } else {

                            getLayer()

                                .AlterFieldDefn(index, fieldDefn, ogrConstants.ALTER_ALL_FLAG);

                        }

                    }

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

                        List<GeomFieldDefn> geometryFields =

                            converter.convertGeometryFields(target, true);

                        for (GeomFieldDefn geomFieldDefn : geometryFields) {

                            int index =

                                getLayer().GetLayerDefn()

                                    .GetGeomFieldIndex(geomFieldDefn.GetName());

                            if (index == -1) {

                                getLayer().CreateGeomField(geomFieldDefn);

                            }

                        }

                    } else {

                        StringBuilder stb = new StringBuilder();

                        stb.append("Driver '");

                        stb.append(getDataSource().GetDriver().GetName());

                        stb.append("' does not support create geometry fields");

                        LOG.warn(stb.toString());

                    }

                }

                while (deleteds.hasNext()) {

                    FeatureReferenceProviderServices reference =

                        (FeatureReferenceProviderServices) deleteds.next();

                    getLayer().DeleteFeature((int) reference.getOID());

                }

                while (inserteds.hasNext()) {

                    FeatureProvider featureProvider = (FeatureProvider) inserteds.next();

                    getLayer().CreateFeature(converter.convert(featureProvider));

                }

                while (updateds.hasNext()) {

                    FeatureProvider featureProvider = (FeatureProvider) updateds.next();

                    Feature ogrFeature = converter.convert(featureProvider);

                    getLayer().SetFeature(ogrFeature);

                }

                if (getLayer().TestCapability(ogrConstants.OLCTransactions)) {

                    getLayer().CommitTransaction();

                }

                getDataSource().SyncToDisk();

                repack();

                getResource().notifyChanges();

                return null;

            }

        });

    }

    protected void repack() throws OGRUnsupportedFormatException {

        LOG.debug("Running SQL: REPACK ".concat(getLayer().GetName()));

        getDataSource().ExecuteSQL("REPACK ".concat(getLayer().GetName()));

    }

    @Override

    public Object createNewOID() {

        try {

            return getFeatureCount() + 1;

        } catch (DataException e) {

            LOG.error("Can't get feature count", e);

            throw new ReadRuntimeException(getFullName(), e);

        }

    }

    @Override

    public FeatureSetProvider createSet(FeatureQuery query, FeatureType featureType)

        throws DataException {

        open();

        return new OGRFetureSetProvider(this, query, featureType);

    }

    @Override

    public long getFeatureCount() throws DataException {

        open();

        return ((Number) getResource().execute(new ResourceAction() {

            @Override

            public Object run() throws Exception {

                return getLayer().GetFeatureCount();

            }

        })).longValue();

    }

    @Override

    public int getOIDType() {

        return DataTypes.LONG;

    }

    @Override

    protected FeatureProvider internalGetFeatureProviderByReference(

        FeatureReferenceProviderServices providerServices, FeatureType featureType)

        throws DataException {

        Feature ogrFeature = getLayer().GetFeature((int) providerServices.getOID());

        FeatureProvider featureProvider =

            new DefaultFeatureProvider(featureType, ogrFeature.GetFID());

        OGRConverter converter = new OGRConverter();

        featureProvider = converter.convert(featureProvider, featureType, ogrFeature);

        return featureProvider;

    }

    private OGRDataStoreParameters getOGRParameters() {

        return (OGRDataStoreParameters) this.getParameters();

    }

    @SuppressWarnings("rawtypes")

    protected String compoundSelect(FeatureType type, Evaluator evaluator,

        FeatureQueryOrder featureQueryOrder) {

        StringBuilder query = new StringBuilder();

        query.append("SELECT ");

        FeatureAttributeDescriptor[] attributeDescriptors = type.getAttributeDescriptors();

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

            query.append(attributeDescriptors[i].getName());

            // Don't add the last comma

            if (i < attributeDescriptors.length - 1) {

                query.append(",");

            }

        }

        query.append(" FROM ");

        query.append("'");

        query.append(getOGRParameters().getLayerName());

        query.append("'");

        if (featureQueryOrder != null && featureQueryOrder.iterator().hasNext()) {

            query.append(" ORDER BY ");

            Iterator iterator = featureQueryOrder.iterator();

            while (iterator.hasNext()) {

                FeatureQueryOrderMember member = (FeatureQueryOrderMember) iterator.next();

                if (member.hasEvaluator()) {

                    // TODO

                } else {

                    query.append(member.getAttributeName());

                }

                if (member.getAscending()) {

                    query.append(" ASC");

                } else {

                    query.append(" DESC");

                }

                if (iterator.hasNext()) {

                    query.append(", ");

                } else {

                    query.append(' ');

                    break;

                }

            }

        }

        return query.toString();

    }

    @Override

    protected void doDispose() throws BaseException {

        super.doDispose();

        getResource().removeConsumer(this);

        this.resourceProvider = null;

        getDataSource().delete();

        this.envelope = null;

        this.newLayer = null;

        this.dataSource = null;

        this.opened = false;

        this.updateSupport = null;

    }

    @Override

    public boolean closeResourceRequested(ResourceProvider resource) {

        try {

            getDataSource().delete();

        } catch (OGRUnsupportedFormatException e) {

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

        }

        this.envelope = null;

        this.newLayer = null;

        this.dataSource = null;

        this.opened = false;

        this.updateSupport = null;

        return true;

    }

    @Override

    public void resourceChanged(ResourceProvider resource) {

        try {

            getDataSource().delete();

        } catch (OGRUnsupportedFormatException e) {

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

        }

        this.envelope = null;

        this.newLayer = null;

        this.dataSource = null;

        this.opened = false;

        this.updateSupport = 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.regex.Matcher;

import java.util.regex.Pattern;

import org.cresques.cts.ICRSFactory;

import org.cresques.cts.IProjection;

import org.gdal.ogr.DataSource;

import org.gdal.ogr.Feature;

import org.gdal.ogr.Geometry;

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

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

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

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

import org.gvsig.fmap.dal.feature.exception.ConcurrentDataModificationException;

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

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

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

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

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

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

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

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

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.exception.BaseException;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 * 

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

 *

 */

public class OGRFetureSetProvider extends AbstractFeatureSetProvider implements FeatureSetProvider,

    ResourceConsumer {

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

    private static final String regularExpresion =

        "\\s*ST_intersects[(]\\s*ST_GeomFromText[(]\\s*'([^']*)'\\s*,\\s*'([^']*)'\\s*[)],\\s*(?s).*";

    /**

     * @param store

     *            Source of this feature set

     * @param query

     *            Query

     * @param featureType

     *            Featuretype requested

     */

    public OGRFetureSetProvider(AbstractFeatureStoreProvider store, FeatureQuery query,

        FeatureType featureType) {

        super(store, query, featureType);

        getStore().getResource().addConsumer(this);

    }

    @Override

    public boolean canFilter() {

        return false;

    }

    @Override

    public boolean canOrder() {

        return true;

    }

    @Override

    public boolean canIterateFromIndex() {

        return true;

    }

    @Override

    public long getSize() throws DataException {

        return getStore().getFeatureCount();

    }

    @Override

    public boolean isEmpty() throws DataException {

        return getSize() == 0;

    }

    @Override

    protected AbstractFeatureProviderIterator createIterator(long index) throws DataException {

        return createFastIterator(index);

    }

    @Override

    protected AbstractFeatureProviderIterator createFastIterator(long index) throws DataException {

        String sql =

            getOGRStoreProvider().compoundSelect(getFeatureType(), getQuery().getFilter(),

                getQuery().getOrder());

        DataSource dataSource = getOGRStoreProvider().getDataSource();

        LOG.debug("Running query {} over {}", new Object[] { sql, dataSource.getName() });

        Layer layer = null;

        if (getOGRStoreProvider().getLayer().TestCapability(ogrConstants.OLCFastSpatialFilter)

            && getQuery().hasFilter()) {

            String evaluatorSQL = getQuery().getFilter().getSQL();

            Pattern pattern = Pattern.compile(regularExpresion);

            Matcher matcher = pattern.matcher(evaluatorSQL);

            if (matcher.matches()) {

                String wktGeometry = matcher.group(1);

                String crsCode = matcher.group(2);

                IProjection projection = CRSFactory.getCRS(crsCode);

                SpatialReference srs =

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

                Geometry ogrGeometry = ogr.CreateGeometryFromWkt(wktGeometry, srs);

                if (getOGRStoreProvider().getDynValue(DataStore.METADATA_CRS) != null) {

                    IProjection projectionProvider =

                        (IProjection) getOGRStoreProvider().getDynValue(DataStore.METADATA_CRS);

                    if (!crsCode.equals(projectionProvider.getAbrev())) {

                        SpatialReference srsDst =

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

                        ogrGeometry.TransformTo(srsDst);

                    }

                }

                layer = dataSource.ExecuteSQL(sql, ogrGeometry);

            }

        } else {

            layer = dataSource.ExecuteSQL(sql);

        }

        if(layer == null){

            LOG.warn("The result of query is null. SQL {} FeatureType {}", sql, getFeatureType());

            LOG.warn("Getting data without SQL filter");

            OGRDataStoreParameters ogrParameters = (OGRDataStoreParameters) getOGRStoreProvider().getParameters();

            layer = dataSource.ExecuteSQL("SELECT * FROM ".concat(ogrParameters.getLayerName()));

        }

        return new OGRFastIterator(getStore(), layer, index);

    }

    @Override

    protected void doDispose() throws BaseException {

        getStore().getResource().removeConsumer(this);

    }

    @Override

    public boolean closeResourceRequested(ResourceProvider resource) {

        return true;

    }

    @Override

    public void resourceChanged(ResourceProvider resource) {

    }

    class OGRFastIterator extends AbstractFeatureProviderIterator implements ResourceConsumer {

        private long index;

        private Layer layer;

        private OGRConverter converter;

        private FeatureProvider featureProvider;

        public OGRFastIterator(FeatureStoreProvider storeProvider, Layer layer, long index)

            throws OGRUnsupportedFormatException {

            super(storeProvider);

            ToolsLocator.getDisposableManager().bind(storeProvider);

            getResource().addConsumer(this);

            this.converter = new OGRConverter();

            this.index = index;

            this.layer = layer;

            this.layer.SetNextByIndex((int) index);

        }

        @Override

        public void remove() {

            Feature ogrFeature;

            ogrFeature = this.layer.GetNextFeature();

            this.layer.DeleteFeature(ogrFeature.GetFID());

            index++;

        }

        @Override

        protected Object internalNext() {

            Feature ogrFeature = this.layer.GetNextFeature();

            this.featureProvider = converter.convert(featureProvider, getFeatureType(), ogrFeature);

            index++;

            return this.featureProvider;

        }

        @Override

        protected boolean internalHasNext() {

            return index < this.layer.GetFeatureCount() ? true : false;

        }

        @Override

        protected void doDispose() throws BaseException {

            ToolsLocator.getDisposableManager().release(getStore());

            getOGRStoreProvider().getDataSource().ReleaseResultSet(layer);

            getResource().removeConsumer(this);

            this.converter = null;

            this.featureProvider = null;

            this.layer = null;

        }

        @Override

        public boolean closeResourceRequested(ResourceProvider resource) {

            this.featureProvider = null;

            return true;

        }

        @Override

        public void resourceChanged(ResourceProvider resource) {

            throw new ConcurrentDataModificationException(getOGRStoreProvider().getName());

        }

    }

    private OGRDataStoreProvider getOGRStoreProvider() {

        return (OGRDataStoreProvider) getStore();

    }

}

/**

 * 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