Application: gvSIG desktop

/* 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.gpe;

import java.io.File;

import java.util.Map;

import org.cresques.cts.IProjection;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataManager;

import org.gvsig.fmap.dal.DataServerExplorer;

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

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

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

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

import org.gvsig.fmap.dal.serverexplorer.filesystem.FilesystemServerExplorerParameters;

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

import org.gvsig.fmap.dal.store.gpe.handlers.FmapContentHandler;

import org.gvsig.fmap.dal.store.gpe.handlers.FmapErrorHandler;

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

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

import org.gvsig.gpe.lib.api.GPELocator;

import org.gvsig.gpe.lib.api.GPEManager;

import org.gvsig.tools.dynobject.DynObject;

import org.gvsig.tools.dynobject.exception.DynFieldNotFoundException;

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

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

/**

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

 */

public class GPEStoreProvider extends AbstractFeatureStoreProvider implements

ResourceConsumer {

    public static final String NAME = "GPE";

    public static final String DESCRIPTION = "GPE file";

    public static final String METADATA_DEFINITION_NAME = NAME;

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

    protected File m_Fich;

    protected boolean isOpen = false;

    //private GPEStoreParameters gpeParams;

    private ResourceProvider gpeResource;

    //Managers to manage the parsing process

    protected GPEManager gpeManager = null;

    protected XMLSchemaManager xmlSchemaManager = null;

    //The content handler and the error handler

    protected FmapContentHandler contentHandler;

    protected FmapErrorHandler errorHandler;

    public GPEStoreProvider(DataStoreParameters params,

        DataStoreProviderServices storeServices)

    throws InitializeException {

        this(params, storeServices, FileHelper

            .newMetadataContainer(METADATA_DEFINITION_NAME));

    }   

    protected GPEStoreProvider(DataStoreParameters params,

        DataStoreProviderServices storeServices, DynObject metadata)

    throws InitializeException {

        super(params, storeServices, metadata);

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

        gpeManager = GPELocator.getGPEManager();

        xmlSchemaManager = XMLSchemaLocator.getXMLSchemaManager();                

        retrieveFile();

        gpeResource = this.createResource(FileResource.NAME,

            new Object[] { m_Fich.getAbsolutePath() });

        gpeResource.addConsumer(this);

        this.initFeatureType();

    }

    protected void retrieveFile() throws InitializeException{

        m_Fich = getGPEParameters().getFile();

    }

    protected void initFeatureType() throws InitializeException {

        try {

            this.open();

        } catch (DataException e) {

            throw new InitializeException(this.getProviderName(), e);

        }

    }

    private GPEStoreParameters getGPEParameters() {

        return (GPEStoreParameters) this.getParameters();

    }

    public Object getDynValue(String name) throws DynFieldNotFoundException {

        if (DataStore.METADATA_CRS.equalsIgnoreCase(name)) {

            IProjection resp = this.getSRS();

            if (resp != null) {

                return resp;

            }

        }

        return super.getDynValue(name);

    }

    /* (non-Javadoc)

     * @see org.gvsig.fmap.dal.resource.spi.ResourceConsumer#closeResourceRequested(org.gvsig.fmap.dal.resource.spi.ResourceProvider)

     */

    public boolean closeResourceRequested(ResourceProvider resource) {

        // TODO Auto-generated method stub

        return false;

    }

    /* (non-Javadoc)

     * @see org.gvsig.fmap.dal.resource.spi.ResourceConsumer#resourceChanged(org.gvsig.fmap.dal.resource.spi.ResourceProvider)

     */

    public void resourceChanged(ResourceProvider resource) {

        // TODO Auto-generated method stub

    }

    /* (non-Javadoc)

     * @see org.gvsig.fmap.dal.feature.spi.FeatureStoreProvider#canWriteGeometry(int)

     */

    public boolean canWriteGeometry(int geometryType, int geometrySubtype)

    throws DataException {

        // TODO Auto-generated method stub

        return false;

    }

    /* (non-Javadoc)

     * @see org.gvsig.fmap.dal.feature.spi.FeatureStoreProvider#createNewOID()

     */

    public Object createNewOID() {

        return contentHandler.createNewOID();

    }

    /* (non-Javadoc)

     * @see org.gvsig.fmap.dal.feature.spi.FeatureStoreProvider#createSet(org.gvsig.fmap.dal.feature.FeatureQuery)

     */

    public FeatureSetProvider createSet(FeatureQuery query)

    throws DataException {

        return new GPESetProvider(this, query);

    }

    protected FeatureProvider internalGetFeatureProviderByReference(

        FeatureReferenceProviderServices reference) throws DataException {

        return internalGetFeatureProviderByReference(reference,

            this

            .getFeatureStore()

            .getDefaultFeatureType());

    }

    public FeatureProvider internalGetFeatureProviderByReference(

        FeatureReferenceProviderServices reference, FeatureType featureType)

    throws DataException {

        Map featureSet = contentHandler.getFeatureSet();

        if (featureSet.containsKey(reference.getOID())){

            return (FeatureProvider)featureSet.get(reference.getOID());

        }

        return null;

    }

    FeatureProvider getFeatureProviderByIndex(Long index, FeatureType fType)

    throws DataException {

        Map featureSet = contentHandler.getFeatureSet();

        if (featureSet.containsKey(index)){

            return (FeatureProvider)featureSet.get(index);

        }        

        return null;

    }

    public void resourcesBegin() throws ResourceExecuteException {

        // Nothing to do

    }

    public void resourcesEnd() {

        // Nothing to do

    }

    /* (non-Javadoc)

     * @see org.gvsig.fmap.dal.feature.spi.FeatureStoreProvider#getFeatureReferenceOIDType()

     */

    public int getOIDType() {

        return DataTypes.STRING;

    }

    /* (non-Javadoc)

     * @see org.gvsig.fmap.dal.feature.spi.FeatureStoreProvider#getName()

     */

    public String getProviderName() {

        return NAME;

    }

    /* (non-Javadoc)

     * @see org.gvsig.fmap.dal.spi.DataStoreProvider#getSourceId()

     */

    public Object getSourceId() {

        return getGPEParameters().getFile();

    }

    public String getName() {

        String name = this.getGPEParameters().getFile().getName();

        int n = name.lastIndexOf(".");

        if( n<1 ) {

            return name;

        }

        return name.substring(0, n);

    }

    public String getFullName() {

        return this.getGPEParameters().getFile().getAbsolutePath();

    }

    /* (non-Javadoc)

     * @see org.gvsig.fmap.dal.spi.DataStoreProvider#open()

     */

    public void open() throws OpenException {

        if (isOpen) {

            return;

        }

        try {

            errorHandler = new FmapErrorHandler();

            contentHandler = new FmapContentHandler(errorHandler,

                getStoreServices(), this, m_Fich,

                getSRS(),

                getGeometryType());

            if (getStoreServices().getDefaultFeatureType() != null){

                contentHandler.setFeatureType(getStoreServices().getDefaultFeatureType().getEditable());

            }

            contentHandler.setEnvelope((Envelope)getDynValue("Envelope"));

            isOpen = true;

            gpeManager.parse(contentHandler, errorHandler, m_Fich.toURI());                        

        } catch (Exception e) {

            throw new OpenException("Imposible create a parser",e);

        }

    }

    protected IProjection getSRS(){

        return getGPEParameters().getCRS();

    }        

    protected int getGeometryType() {

        return TYPES.GEOMETRY;

    }

    /* (non-Javadoc)

     * @see org.gvsig.fmap.dal.feature.spi.FeatureStoreProvider#createSet(org.gvsig.fmap.dal.feature.FeatureQuery, org.gvsig.fmap.dal.feature.FeatureType)

     */

    public FeatureSetProvider createSet(FeatureQuery query,

        FeatureType featureType) throws DataException {

        return new GPESetProvider(this, query, featureType);

    }

    public long getFeatureCount() throws DataException {                

        return contentHandler.getFeaturesCount();

    }

    /* (non-Javadoc)

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

     */

    public Envelope getEnvelope() throws DataException {

        this.open();

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

    }

    public void setEnvelope(Envelope envelope) {

        this.setDynValue("Envelope", envelope);

    }

    public ResourceProvider getResource() {

        return gpeResource;

    }

    public DataServerExplorer getExplorer() throws ReadException,

    ValidateDataParametersException {

        DataManager manager = DALLocator.getDataManager();

        FilesystemServerExplorerParameters params;

        try {

            params = (FilesystemServerExplorerParameters) manager

            .createServerExplorerParameters(FilesystemServerExplorer.NAME);

            params.setRoot(this.getGPEParameters().getFile().getParent());

            return manager.createServerExplorer(params);

        } catch (DataException e) {

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

        } catch (ValidateDataParametersException e) {

            // TODO Auto-generated catch block

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

        }

    }

    /**

     * @return the contentHandler

     */

    public FmapContentHandler getContentHandler() {

        return contentHandler;

    }

    /**

     * @return the errorHandler

     */

    public FmapErrorHandler getErrorHandler() {

        return errorHandler;

    }

}