Application: gvSIG desktop » gvSIG data providers based on gdal

/**

 * gvSIG. Desktop Geographic Information System.

 *

 * Copyright ? 2007-2016 gvSIG Association

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 2

 * of the License, or (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

 * MA  02110-1301, USA.

 *

 * For any additional information, do not hesitate to contact us

 * at info AT gvsig.com, or visit our website www.gvsig.com.

 */

package org.gvsig.gdal.prov.ogr;

import java.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;

        boolean ignoreSpatialFilter = (boolean) getStore().getParameters().getDynValue(OGRDataStoreParameters.IGNORE_SPATIAL_FILTER);

        if (!ignoreSpatialFilter && 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;

        private Feature currentOgrFeature;

        private Feature nextOgrFeature;

        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.GetFeatureCount();

            this.layer.ResetReading();

            if(index!=0){

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

            }

            this.currentOgrFeature = null;

            this.nextOgrFeature =  this.layer.GetNextFeature();

        }

        @Override

        public void remove() {

            if (currentOgrFeature != null) {

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

                currentOgrFeature=null;

            }

        }

        @Override

        protected Object internalNext() {

            this.currentOgrFeature = this.nextOgrFeature;

            this.featureProvider = null;

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

            this.nextOgrFeature =  this.layer.GetNextFeature();

            return this.featureProvider;

        }

        @Override

        protected boolean internalHasNext() {

            return nextOgrFeature!=null;

        }

        @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();

    }

}