Application: gvSIG desktop » gvSIG data provider for WFS

/* gvSIG. Geographic Information System of the Valencian Government

 *

 * Copyright (C) 2007-2008 Infrastructures and Transports Department

 * of the Valencian Government (CIT)

 *

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

 *

 */

/*

 * AUTHORS (In addition to CIT):

 * 2009 {Iver T.I.}   {Task}

 */

package org.gvsig.fmap.dal.store.wfs;

import java.io.File;

import java.io.IOException;

import java.util.ArrayList;

import java.util.Iterator;

import java.util.List;

import org.cresques.cts.ICoordTrans;

import org.cresques.cts.IProjection;

import org.gvsig.fmap.crs.CRSFactory;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataManager;

import org.gvsig.fmap.dal.DataServerExplorer;

import org.gvsig.fmap.dal.DataStoreParameters;

import org.gvsig.fmap.dal.DataTypes;

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

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

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

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

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

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

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

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

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

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

import org.gvsig.fmap.dal.serverexplorer.wfs.WFSServerExplorer;

import org.gvsig.fmap.dal.serverexplorer.wfs.WFSServerExplorerParameters;

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

import org.gvsig.fmap.dal.store.gpe.GPEStoreProvider;

import org.gvsig.fmap.geom.Geometry;

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

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.GeometryManager;

import org.gvsig.fmap.geom.exception.CreateEnvelopeException;

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

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

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

import org.gvsig.gpe.lib.api.exceptions.WriterHandlerCreationException;

import org.gvsig.metadata.MetadataLocator;

import org.gvsig.metadata.MetadataManager;

import org.gvsig.metadata.exceptions.MetadataException;

import org.gvsig.remoteclient.ogc.OGCClientOperation;

import org.gvsig.remoteclient.utils.BoundaryBox;

import org.gvsig.remoteclient.wfs.WFSClient;

import org.gvsig.remoteclient.wfs.WFSFeature;

import org.gvsig.remoteclient.wfs.WFSFeatureField;

import org.gvsig.remoteclient.wfs.WFSStatus;

import org.gvsig.remoteclient.wfs.exceptions.WFSException;

import org.gvsig.remoteclient.wfs.filters.filterencoding.FilterEncoding;

import org.gvsig.remoteclient.wfs.request.WFSGetFeatureRequestInformation;

import org.gvsig.remoteclient.wfs.request.WFSTransactionRequestInformation;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dynobject.DynStruct;

import org.gvsig.tools.evaluator.EvaluatorFieldValue;

import org.gvsig.tools.evaluator.EvaluatorFieldValueMatch;

import org.gvsig.tools.evaluator.EvaluatorFieldsInfo;

import org.gvsig.xmlschema.lib.api.XMLSchemaLocator;

import org.gvsig.xmlschema.lib.api.XMLSchemaManager;

import org.gvsig.xmlschema.lib.api.som.IXSGeometryTypeDefinition;

import org.gvsig.xmlschema.lib.api.som.IXSTypeDefinition;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 * @author <a href="mailto:jpiera@gvsig.org">Jorge Piera</a>

 */

public class WFSStoreProvider extends AbstractFeatureStoreProvider {

    private static final Logger logger = LoggerFactory.getLogger(WFSStoreProvider.class);

    public static String NAME = "WFSStore";

    public static String DESCRIPTION = "WFS store to load WFS resources";

    private static final MetadataManager metadataManager = MetadataLocator.getMetadataManager();

    private static final String METADATA_DEFINITION_NAME = "WFSStore";    

    private static final String METADATA_DEFINITION_DESCRIPTION = "WFSStore metadata definition";

    // private IProjection projection;        

    private long featureCount = -1;

    private boolean isKnownEnvelope = false;

    /**

     * If the user has selected the filter by area option

     */

    private boolean hasFilterByArea = false;

    /**

     * GML provider used by delegation to read the GML files

     */

    private GPEStoreProvider storeProviderDelegate = null;

    private static final DataManager dataManager = DALLocator.getDataManager();   

    private static final XMLSchemaManager xmlSchemaManager = XMLSchemaLocator.getXMLSchemaManager();          

    boolean isFilterByAreaSupported = true;

    //WFS Parameters

    private WFSClient wfsClient;

    private WFSStatus wfsStatus;

    public WFSStoreProvider(DataStoreParameters params,

        DataStoreProviderServices storeServices)

    throws InitializeException {

        super(params, storeServices, 

            ToolsLocator.getDynObjectManager().createDynObject(metadataManager.getDefinition(METADATA_DEFINITION_NAME)));                

        initParams();

        try {

            initFeatureType();

        } catch (WFSException e) {

            throw new InitializeException(e);

        } catch (ReadException e) {

            throw new InitializeException(e);

        }

    }

    private void initParams() throws InitializeException{

        try {

            WFSStoreParameters wfsParameters = getWFSParameters();

            try {

                if (wfsParameters.getVersion() == null){

                    wfsClient = new WFSClient(wfsParameters.getUrl(), wfsParameters.getIgnoreCache());

                    wfsParameters.setVersion(wfsClient.getVersion());

                }else{

                    wfsClient = new WFSClient(wfsParameters.getUrl(), wfsParameters.getVersion(), wfsParameters.getIgnoreCache());

                }

            } catch (IOException e) {

                throw new InitializeException(e);

            }

            wfsStatus = new WFSStatus( wfsParameters.getFeatureType(),

                wfsParameters.getFeatureNamespace());

            wfsStatus.setNamespacePrefix(wfsParameters.getFeaturePrefix());

            wfsStatus.setFields(wfsParameters.getFields());

            //Select the filter by area

            wfsStatus.setFilterByArea(wfsParameters.getFilterByAreaGeometry(), wfsParameters.getFilterByAreaAttribute(), 

                wfsParameters.getFilterByAreaCrs(), wfsParameters.getFilterByAreaOperation());

            this.hasFilterByArea = (wfsStatus.getFilterByArea() != null);

            //Select the filter by attribute

            wfsStatus.setFilterByAttribute(wfsParameters.getFilterEncodingByAttribute());

            String _srs = wfsParameters.getFilterByAreaCrs();

            wfsStatus.setSrs(_srs);

            wfsStatus.setTimeout(wfsParameters.getTimeOut());

            wfsStatus.setMaxFeatures(wfsParameters.getMaxFeatures());

            wfsStatus.setUserName(wfsParameters.getUser());

            wfsStatus.setPassword(wfsParameters.getPassword());

            //Setting the envelope for the layer

            wfsClient.getCapabilities(wfsStatus, false, null);

            Envelope envelope = calculateFullEnvelope();

            if (envelope != null){

                this.setDynValue("Envelope", envelope);

                isKnownEnvelope = true;

            }                        

        } catch (WFSException e) {

            throw new InitializeException("Impossible to retrieve the file", e);

        }

    }

    private WFSFeature getSelectedWFSFeature() throws ReadException, WFSException{

        WFSStoreParameters wfsParameters = getWFSParameters();

        return  ((WFSServerExplorer)getExplorer()).getFeatureInfo(wfsParameters.getFeatureNamespace(),

            wfsParameters.getFeatureType());

    }

    private void initFeatureType() throws WFSException, ReadException{           

        WFSFeature feature  = getSelectedWFSFeature();

        if (feature == null){

            //TODO read from GML

            throw new WFSException("It is not possible to parse the schema");

        }

        IProjection ipro = null;

        try {

            ipro = CRSFactory.getCRS(wfsStatus.getSrs());

            this.setDynValue("CRS", ipro);

        } catch (Exception ex) {

            logger.info("Error: did not set CRS in store provider.", ex);

        }

        EditableFeatureType featureType = getStoreServices().createFeatureType();

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

            WFSFeatureField featureField = feature.getFieldAt(i);           

            int dataType = DataTypes.STRING;               

            String typeName = featureField.getType();

            EditableFeatureAttributeDescriptor attributeDescriptor = null;

            IXSTypeDefinition typeDefinition = null;

            if (typeName != null){

                typeDefinition = xmlSchemaManager.getTypeDefinition(typeName);

            }

            if (typeDefinition != null){             

                if (typeDefinition.getDataType() != null){

                    if (typeDefinition.getDataType().getType() == DataTypes.GEOMETRY){

                        dataType = typeDefinition.getDataType().getType();

                    }

                }

                attributeDescriptor = featureType.add(featureField.getName(), dataType);   

                if (typeDefinition instanceof IXSGeometryTypeDefinition){

                    if (ipro != null) {

                        attributeDescriptor.setSRS(ipro);

                    } else {

                        if (feature.getSrs().size() > 0){

                            attributeDescriptor.setSRS(CRSFactory.getCRS((String)feature.getSrs().get(0)));

                        } else {

                            logger.info("Unable to set CRS in feature type.");

                        }

                    }

                    attributeDescriptor.setGeometryType(((IXSGeometryTypeDefinition)typeDefinition).getGeometryType());

                    attributeDescriptor.setGeometrySubType(SUBTYPES.GEOM3D);

                    featureType.setDefaultGeometryAttributeName(featureField.getName());

                }                               

            }else{

                attributeDescriptor = featureType.add(typeName, dataType);    

            }    

            // length, relevant for all (strings) except geometry

            attributeDescriptor.setSize(128);

        }       

        featureType.setHasOID(true);

        FeatureType defaultType = featureType.getNotEditableCopy();

        List types = new ArrayList(1);

        types.add(defaultType);

        this.getStoreServices().setFeatureTypes(types, defaultType);

    }

    private Envelope calculateFullEnvelope() {

        GeometryManager geometryManager = GeometryLocator.getGeometryManager();

        try{

            WFSFeature feature  = getSelectedWFSFeature();

            if (feature != null){ 

                String _srs = wfsStatus.getSrs();

                if (_srs != null) {

                    BoundaryBox boundaryBox = feature.getBbox(_srs);

                    //The projection is found

                    if (boundaryBox != null){

                        return geometryManager.createEnvelope(boundaryBox.getXmin(),

                            boundaryBox.getYmin(), boundaryBox.getXmax(), boundaryBox.getYmax(), SUBTYPES.GEOM2D);

                    }

                    //Check if there is a latlon envelope

                    boundaryBox = feature.getLatLonBbox();

                    if (boundaryBox != null){

                        Envelope envelope = geometryManager.createEnvelope(boundaryBox.getXmin(),

                            boundaryBox.getYmin(), boundaryBox.getXmax(), boundaryBox.getYmax(), SUBTYPES.GEOM2D);

                        if (!"EPSG:4326".equals(_srs)){

                            IProjection sourceProjection = CRSFactory.getCRS("EPSG:4326");

                            IProjection destinationProjection = CRSFactory.getCRS(_srs);

                            if (destinationProjection != null){

                                ICoordTrans coordTrans = sourceProjection.getCT(destinationProjection);

                                return envelope.convert(coordTrans);

                            }        

                        }

                    }

                }else{

                    //If there is not a SRS is thrown a request for the first 500 features

                    int odlMaxFeatures = wfsStatus.getMaxFeatures();

                    wfsStatus.setMaxFeatures(500);

                    createSet(null, null);

                    return storeProviderDelegate.getEnvelope();

                }

            }

        }catch(CreateEnvelopeException e){

            logger.error("Impossible to create an envelope", e);

        } catch (ReadException e) {

            logger.error("Impossible to create an envelope", e);

        } catch (WFSException e) {

            logger.error("Impossible to create an envelope", e);

        } catch (DataException e) {

            logger.error("Impossible to create an envelope", e);

        }

        return null;

    }

    private WFSStoreParameters getWFSParameters() {

        return (WFSStoreParameters) getParameters();

    }

    /* (non-Javadoc)

     * @see org.gvsig.fmap.dal.store.gpe.GPEStoreProvider#open()

     */

    public void open() throws OpenException {

        try {

            List featureTypes = this.getFeatureStore().getFeatureTypes();

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

                FeatureType featureType = (FeatureType)featureTypes.get(i);

            }

        } catch (DataException e) {

            throw new OpenException("Reading the geometry type", e);

        }

    }

    protected static void registerMetadataDefinition() throws MetadataException {       

        if (metadataManager.getDefinition(METADATA_DEFINITION_NAME) == null) {

            DynStruct metadataDefinition = metadataManager.addDefinition(

                METADATA_DEFINITION_NAME, METADATA_DEFINITION_DESCRIPTION);

            metadataDefinition.addDynFieldObject("Envelope").setClassOfValue(Envelope.class).setMandatory(false);

            metadataDefinition.addDynFieldObject("CRS").setClassOfValue(IProjection.class).setMandatory(true);

            metadataDefinition.extend(metadataManager

                .getDefinition(FeatureStore.METADATA_DEFINITION_NAME));

        }

    }

    /* (non-Javadoc)

     * @see org.gvsig.fmap.dal.feature.spi.AbstractFeatureStoreProvider#getExplorer()

     */

    public DataServerExplorer getExplorer() throws ReadException {

        DataManager manager = DALLocator.getDataManager();

        WFSServerExplorerParameters params;

        try {

            params = (WFSServerExplorerParameters) manager

            .createServerExplorerParameters(WFSServerExplorer.NAME);

            params.setUrl(wfsClient.getHost());

            return manager.openServerExplorer(WFSServerExplorer.NAME,params);

        } catch (Exception e) {

            throw new ReadException(this.getName(), e);

        }

    }

    public String getProviderName() {

        return NAME;

    }

    public FeatureSetProvider createSet(FeatureQuery query)

    throws DataException {

        return createSet(query, null);

    }

    public FeatureSetProvider createSet(FeatureQuery query,

        FeatureType featureType) throws DataException {

        if ((featureCount == -1) ||

            (storeProviderDelegate == null) ||

            (featureCount >= wfsStatus.getMaxFeatures())){ 

            File file = null;

            if (query == null){

                file = executeQuery();   

            }else{

                //If it is possible to execute a spatial query...

                if ((query.getFilter() != null) && (!hasFilterByArea)){

                    file = executeSpatialQuery(query);

                }else{

                    file = executeQuery();   

                }        

            }

            storeProviderDelegate = createProvider(file);

        }

        return storeProviderDelegate.createSet(query, featureType);

    }

    /**

     * It creates the provider that is used to retrieve features from a file.

     * @param file

     * the file that contains the downloaded file

     * @return

     * @throws InitializeException

     * @throws ProviderNotRegisteredException

     */

    private GPEStoreProvider createProvider(File file) throws InitializeException, ProviderNotRegisteredException{

        return new GPEStoreProvider(createStoreParameters(file), getStoreServices());

    }        

    private DataStoreParameters createStoreParameters(File file) throws InitializeException, ProviderNotRegisteredException{

        DataStoreParameters parameters = dataManager.createStoreParameters(GPEStoreProvider.NAME);

        parameters.setDynValue("File", file.getAbsolutePath());

        parameters.setDynValue("Envelope", this.getDynValue("Envelope"));

        parameters.setDynValue("useAxisOrderYX", this.getWFSParameters().getUseAxisOrderYX());

        return parameters;

    }

    /**

     * It executes a wfs Query without spatial filter

     * @throws DataException

     */

    private File executeQuery() throws DataException{

        try{

            wfsStatus.setResultType(WFSStatus.RESULTYPE_RESULTS);

            if (!hasFilterByArea){

                wfsStatus.removeFilterByArea();

            }

            return wfsClient.getFeature(wfsStatus, getWFSParameters().getIgnoreCache(), null);

        } catch (WFSException e) {

            throw new InitializeException("Impossible to retrieve the file", e);

        }

    }

    /**

     * Executes a new query sending the FilterEncoding request to the server

     * @param query

     * The Query to send

     * @throws InitializeException

     * If there is a problem with the request or the parsing process

     */

    private File executeSpatialQuery(FeatureQuery query) throws DataException{

        EvaluatorFieldsInfo fieldsInfo = query.getFilter().getFieldsInfo();

        String[] fields = fieldsInfo.getFieldNames();

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

            EvaluatorFieldValue[] evaluatorFieldValues = fieldsInfo.getFieldValues(fields[i]);

            for (int j=0 ; j<evaluatorFieldValues.length ; j++){                                

                if (EvaluatorFieldValue.MATCH == evaluatorFieldValues[j].getType()){

                    EvaluatorFieldValueMatch evaluatorFieldValueMatch = (EvaluatorFieldValueMatch)evaluatorFieldValues[j];

                    Object area = evaluatorFieldValueMatch.getValue();

                    if (area instanceof Envelope){

                        return executeSpatialQueryFromEnvelope(evaluatorFieldValueMatch.getFieldName(),

                            (Envelope)area);                                        

                    }else if (area instanceof Geometry){

                        return executeSpatialQueryFromGeometry(evaluatorFieldValueMatch.getFieldName(),

                            (Geometry)area);                                                

                    }

                }

            }                        

        }

        return null;

    }

    private File executeSpatialQueryFromGeometry(String the_geom, Geometry geometry) throws DataException{

        wfsStatus.setFilterByArea(geometry, the_geom, wfsStatus.getSrs(), 

            FilterEncoding.GEOMETRIC_OPERATOR_CONTAINS);

        return executeSpatialQuery();

    }

    private File executeSpatialQueryFromEnvelope(String the_geom, Envelope envelope) throws DataException{

        wfsStatus.setFilterByArea(envelope, the_geom, wfsStatus.getSrs(), 

            FilterEncoding.GEOMETRIC_OPERATOR_CONTAINS);                

        return executeSpatialQuery();

    }

    private File executeSpatialQuery() throws DataException{

        try {

            wfsStatus.setProtocol(OGCClientOperation.PROTOCOL_POST);

            //If it is not possible to calculate the 

            wfsStatus.setResultType(WFSStatus.RESULTYPE_RESULTS);

            return wfsClient.getFeature(wfsStatus, getWFSParameters().getIgnoreCache(), null);

        } catch (WFSException e) {

            throw new InitializeException("Impossible to retrieve the file", e);

        }

    }                

    public Object getSourceId() {

        StringBuffer sourceID = new StringBuffer(getWFSParameters().getUrl());

        sourceID.append("_" + getWFSParameters().getFeatureType());

        int hash = sourceID.hashCode();

        if (sourceID.length() > 60){

            return sourceID.substring(0, 60) + "_" + hash;

        }else{

            return sourceID.toString() + "_" + hash;

        }

    }

    public Object createNewOID() {        

        try {

            return String.valueOf(getFeatureCount()+1);

        } catch (DataException e) {

            return String.valueOf(Math.random());

        }

    }

    public long getFeatureCount() throws DataException {

        if (featureCount == -1){

            wfsStatus.setResultType(WFSStatus.RESULTYPE_HITS);

            try {

                //The filter encoding is better supported using POST

                if (hasFilterByArea){

                    wfsStatus.setProtocol(OGCClientOperation.PROTOCOL_POST);

                }else{

                    wfsStatus.setProtocol(OGCClientOperation.PROTOCOL_GET);

                }

                File file = wfsClient.getFeature(wfsStatus, getWFSParameters().getIgnoreCache(), null);

                featureCount = ((WFSGetFeatureRequestInformation)wfsClient.getLastWfsRequestInformation()).getNumberOfFeatures();

                //If the service doesn't support RESULTTYPE_HITS, parse the file and get the FeatureCount

                if (featureCount == -1){

                    storeProviderDelegate = createProvider(file);

                    featureCount = storeProviderDelegate.getFeatureCount();

                }

            } catch (WFSException e) {

                throw new ConnectionServerException("Error calculating the feature count", e);

            }

        }

        return featureCount;

    }

    public int getOIDType() {

        return DataTypes.STRING;

    }

    public ResourceProvider getResource() {

        return storeProviderDelegate.getResource();

    }

    protected FeatureProvider internalGetFeatureProviderByReference(

        FeatureReferenceProviderServices reference, FeatureType featureType)

    throws DataException {

        return storeProviderDelegate.internalGetFeatureProviderByReference(reference, featureType);

    }

    public String getFullName() {       

        return getWFSParameters().getUrl() + "_" + getWFSParameters().getFeatureType();

    }

    public String getName() {        

        return getWFSParameters().getFeatureType();

    }

    public boolean isKnownEnvelope(){  

        return isKnownEnvelope;

    }

    public boolean hasRetrievedFeaturesLimit(){

        return true;

    }

    public int getRetrievedFeaturesLimit(){

        //WFS 1.0.0 can not know where is the limit

        if (getWFSParameters().getVersion().equals("1.0.0")){

            return 0;

        }else{

            return wfsClient.getServiceInformation().getMaxFeatures();

        }

    }

    public void performChanges(Iterator deleteds, Iterator inserteds,

        Iterator updateds, Iterator featureTypesChanged)

    throws DataException {

        wfsStatus.setProtocol(OGCClientOperation.PROTOCOL_POST);

        WFSTTransactionBuilder transactionBuilder = new WFSTTransactionBuilder(wfsStatus, wfsClient);

        //Create the Query

        try {

            //Add new features

            while (inserteds.hasNext()){

                transactionBuilder.addInsertFeature((FeatureProvider)inserteds.next());

            }

            //Add deleted features

            while (deleteds.hasNext()){

                transactionBuilder.addDeleteFeature(

                    internalGetFeatureProviderByReference((FeatureReferenceProviderServices)deleteds.next(), null).getOID().toString());;

            }

            //Add updated features

            while (updateds.hasNext()){

                transactionBuilder.addUpdateFeature((FeatureProvider)updateds.next());

            }

        } catch (WriterHandlerCreationException e) {

            throw new WFSTTRansactionException(e);

        } catch (GeometryOperationNotSupportedException e) {

            throw new WFSTTRansactionException(e);

        } catch (GeometryOperationException e) {

            throw new WFSTTRansactionException(e);

        }

        //Send the query to the server

        try {

            wfsClient.transaction(wfsStatus, true, null);

            WFSTransactionRequestInformation transactionRequestInformation =  (WFSTransactionRequestInformation)wfsClient.getLastWfsRequestInformation();

            if (transactionRequestInformation.getStatus() == WFSTransactionRequestInformation.STATUS_FAILED){

                throw new WFSTTRansactionException(transactionRequestInformation.getMessage());

            }

        } catch (WFSException e) {

            throw new WFSTTRansactionException(e);

        }

    }

    public boolean allowWrite() {

        return wfsClient.getServiceInformation().isOperationSupported("Transaction");

    }

    public Envelope getEnvelope() throws DataException {        

        return (Envelope) this.getDynValue("Envelope");

    }

    public FeatureProvider createFeatureProvider(FeatureType type)

    throws DataException {       

        return super.createFeatureProvider(type);

    }

}