Application: gvSIG desktop

/**

 * gvSIG. Desktop Geographic Information System.

 *

 * Copyright (C) 2007-2013 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 3

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

 */

/*

* AUTHORS (In addition to CIT):

* 2008 IVER T.I. S.A.   {{Task}}

*/

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

import java.io.File;

import java.io.IOException;

import java.util.Iterator;

import org.apache.commons.io.FileUtils;

import org.cresques.cts.IProjection;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.gvsig.fmap.dal.DataStore;

import org.gvsig.fmap.dal.DataTypes;

import org.gvsig.fmap.dal.FileHelper;

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

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.feature.EditableFeatureAttributeDescriptor;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

import org.gvsig.fmap.dal.resource.file.FileResource;

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

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

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

import org.gvsig.fmap.dal.store.dbf.DBFStoreParameters;

import org.gvsig.fmap.dal.store.dbf.DBFStoreProvider;

import org.gvsig.fmap.dal.store.shp.utils.SHPFile;

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.exception.CreateGeometryException;

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

import org.gvsig.tools.dispose.DisposableIterator;

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

import org.gvsig.tools.exception.BaseException;

public class SHPStoreProvider extends DBFStoreProvider {

        private static final GeometryManager geomManager = GeometryLocator.getGeometryManager();

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

        public static String NAME = "Shape";

        public static String DESCRIPTION = "Shape file";

        private SHPFile shpFile;

        private MultiResource resource;

        protected static final String GEOMETRY_ATTIBUTE_NAME = "GEOMETRY";

        public static final String METADATA_DEFINITION_NAME = NAME;

        private SHPFeatureWriter writer = null;

        public SHPStoreProvider(SHPStoreParameters params,

                        DataStoreProviderServices storeServices)

                        throws InitializeException {

                super(

                        params, 

                        storeServices,

                        FileHelper.newMetadataContainer(METADATA_DEFINITION_NAME)

                );

        }

        protected void init(DBFStoreParameters params,

                        DataStoreProviderServices storeServices) throws InitializeException {

                this.shpFile = new SHPFile((SHPStoreParameters) params);

                super.init(params, storeServices);

        }

        public Object getDynValue(String name) throws DynFieldNotFoundException {

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

                        /*

                         * String srs =  this.shpFile.getSRSParameters();

                        if (srs != null){

                        // This can be non null but not sure how to handle

                        }

                        */

                        return this.getShpParameters().getCRS();

                } else if( DataStore.METADATA_ENVELOPE.equalsIgnoreCase(name) ) {

                        try {

                                return this.shpFile.getFullExtent();

                        } catch (ReadException e) {

                                return null;

                        }

                }

                return super.getDynValue(name);

        }

        protected void initResource(DBFStoreParameters params,

                        DataStoreProviderServices storeServices) throws InitializeException {

                SHPStoreParameters shpParams = (SHPStoreParameters) params;

                resource =

                                (MultiResource) createResource(MultiResource.TYPE_NAME,

                                                new Object[] { shpParams.getSHPFileName() });

                resource.addResource(FileResource.NAME,

                                new Object[] { shpParams.getSHPFileName() }, true);

                resource.addResource(FileResource.NAME,

                                new Object[] { shpParams.getSHXFileName() }, true);

                resource.addResource(FileResource.NAME,

                                new Object[] { shpParams.getDBFFileName() }, true);

                resource.addConsumer(this);

        };

        public ResourceProvider getResource() {

                return resource;

        }

        /**

         *

         * @throws ResourceNotifyChangesException

         */

        protected void resourcesNotifyChanges()

                        throws ResourceNotifyChangesException {

                // super.resourcesNotifyChanges();

                // this.shpResource.notifyChanges();

                // this.shxResource.notifyChanges();

                getResource().notifyChanges();

                // TODO .prj

        }

        /**

         * @throws ResourceNotifyCloseException

         *

         */

        protected void resourcesNotifyClose() throws ResourceNotifyCloseException {

//                super.resourcesNotifyClose();

//                this.shpResource.notifyClose();

//                this.shxResource.notifyClose();

                getResource().notifyClose();

                // TODO .prj

        }

        @Override

        protected void doDispose() throws BaseException {

                super.doDispose();

                getResource().removeConsumer(this);

                this.writer = null;

                this.shpFile = null;

        }

        protected void disposeResource() {

                getResource().removeConsumer(this);

        }

        /**

         * @throws ResourceNotifyOpenException

         *

         */

        protected void resourcesOpen() throws ResourceNotifyOpenException {

                // super.resourcesOpen();

                // this.shpResource.notifyOpen();

                // this.shxResource.notifyOpen();

                getResource().notifyOpen();

        }

        protected static EditableFeatureAttributeDescriptor addGeometryColumn(

                        EditableFeatureType fType) {

                EditableFeatureAttributeDescriptor attrTmp = null;

                EditableFeatureAttributeDescriptor attr = null;

                Iterator iter = fType.iterator();

                while (iter.hasNext()) {

                        attrTmp = (EditableFeatureAttributeDescriptor) iter.next();

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

                                if (attr != null) {

                                        // Two geom fields not allowed

                                        fType.remove(attrTmp.getName());

                                } else {

                                        attr = attrTmp;

                                        attr.setName(GEOMETRY_ATTIBUTE_NAME);

                                }

                        }

                }

                if (attr == null){

                        attr = fType.add(

                                        GEOMETRY_ATTIBUTE_NAME, DataTypes.GEOMETRY);

                        try {

                                attr.setDefaultValue(geomManager

                                                .createNullGeometry(SUBTYPES.GEOM2D));

                        } catch (CreateGeometryException e) {

                                logger.error("Error creating the envelope", e);

                        }

                }

                attr.setObjectClass(Geometry.class);                

                fType.setDefaultGeometryAttributeName(attr.getName());

                return attr;

        }

        protected static FeatureType removeGeometryColumn(

                        EditableFeatureType fType) {

                Iterator iter = fType.iterator();

                FeatureAttributeDescriptor attr;

                while (iter.hasNext()) {

                        attr = (FeatureAttributeDescriptor) iter.next();

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

                                iter.remove();

                        }

                }

                fType.setDefaultGeometryAttributeName(null);

                return fType.getNotEditableCopy();

        }

        protected EditableFeatureType getTheFeatureType()

                        throws InitializeException, OpenException {

                final EditableFeatureType fType = super.getTheFeatureType();

                this.open();

                // try {

                // this.resourcesBegin();

                // } catch (DataException e) {

                // throw new InitializeException(this.getName(), e);

                // }

                try {

                        getResource().execute(new ResourceAction() {

                                public Object run() throws Exception {

                                        EditableFeatureAttributeDescriptor attr =

                                                        addGeometryColumn(fType);

                                        attr.setGeometryType(shpFile.getGeometryType());

                                        attr.setGeometrySubType(shpFile.getGeometrySubType());

                                        IProjection srs = getShpParameters().getCRS();

                                        attr.setSRS(srs);

                                        return null;

                                }

                        });

                        return fType;

                } catch (ResourceExecuteException e) {

                        throw new InitializeException(e);

                        // } finally {

                        // this.resourcesEnd();

                }

        }

//        private String getSRSFromPrj(String srsParameters) {

//                // TODO identificar que SRS hay que usar, ya sea

//                // el que se recibe de los parametros o el que

//                // conicida con el que se ha encontrado en el

//                // prg... y si ninguna de las dos que?

//                return null;

//        }

        protected SHPStoreParameters getShpParameters() {

                return (SHPStoreParameters) getParameters();

        }

        public String getProviderName() {

                return NAME;

        }

        public boolean allowWrite() {

                return this.shpFile.isEditable();

        }

        /**

         *

         * @param index

         * @param featureType

         * @return

         * @throws ReadException

         */

        protected FeatureProvider getFeatureProviderByIndex(long index,

                        FeatureType featureType) throws DataException {

                // this.open();

                // this.resourcesBegin();

                try {

                        FeatureProvider featureProvider = super.getFeatureProviderByIndex(index,

                                        featureType);

                        featureProvider.setDefaultEnvelope(this.shpFile.getBoundingBox(index));

                        return featureProvider;

                } catch (DataException e) {

                        throw e;

                } catch (CreateEnvelopeException e) {

                        throw new org.gvsig.fmap.dal.feature.exception.CreateGeometryException(e);                

                } catch (CreateGeometryException e) {

                    throw new org.gvsig.fmap.dal.feature.exception.CreateGeometryException(e);

        }

        }

        protected void initFeatureProviderByIndex(FeatureProvider featureProvider,

                        long index, FeatureType featureType) throws DataException {

                // this.open();

                // this.resourcesBegin();

                try {

                        super.initFeatureProviderByIndex(featureProvider, index, featureType);

                        featureProvider.setDefaultEnvelope(this.shpFile.getBoundingBox(index));

                } catch (CreateEnvelopeException e) {

                        throw new org.gvsig.fmap.dal.feature.exception.CreateGeometryException(e);                        

                } catch (CreateGeometryException e) {

                    throw new org.gvsig.fmap.dal.feature.exception.CreateGeometryException(e);       

        }

        }

        /**

         *

         * @param featureProvider

         * @throws DataException

         */

        protected void loadFeatureProviderByIndex(FeatureProvider featureProvider)

                        throws DataException {

                // this.open();

                // this.resourcesBegin();

                // try {

                        FeatureType featureType = featureProvider.getType();

                        long index = ((Long) featureProvider.getOID()).longValue();

                        boolean hasGeometry = false;

                        if (featureType.getIndex(featureType.getDefaultGeometryAttributeName()) >= 0) {

                                try {

                                        featureProvider.setDefaultGeometry(this.shpFile.getGeometry(index));

                                        hasGeometry = true;

                                } catch (CreateGeometryException e) {

                                        throw new ReadException(getProviderName(), e);

                                }

                        }

                        if (hasDBFAttributes(featureType, hasGeometry)) {

                                super.loadFeatureProviderByIndex(featureProvider);

                        }

                // } finally {

                // this.resourcesEnd();

                // }

        }

        private boolean hasDBFAttributes(FeatureType featureType,

                        boolean hasGeometry) {

                FeatureAttributeDescriptor[] attributes =

                                featureType.getAttributeDescriptors();

                // If there aren't any attributes, nor has any DBF attributes

                if (attributes == null || attributes.length == 0) {

                        return false;

                }

                // If there is only one attribute and it is the geometry one

                if (attributes.length == 1 && hasGeometry) {

                        return false;

                }

                // In any other case

                return true;

        }

        protected void loadValue(FeatureProvider featureProvider, int rowIndex,

                        FeatureAttributeDescriptor descriptor) throws ReadException {

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

                        return;

                } else {

                        super.loadValue(featureProvider, rowIndex, descriptor);

                }

        }

        public FeatureProvider createFeatureProvider(FeatureType type) throws DataException {

                FeatureProvider data = new SHPFeatureProvider(this, type);

                return data;

        }

        protected void openFile() throws IOException, DataException {

                super.openFile();

                this.shpFile.open();

        }

        protected void closeFile() throws CloseException {

                super.closeFile();

                if (!this.shpFile.isOpen()) {

                        return;

                }

                this.shpFile.close();

        }

        public boolean canWriteGeometry(final int geometryType, int geometrySubType)

                        throws DataException {

                this.open();

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

                        public Object run() throws Exception {

                                boolean value = shpFile.canWriteGeometry(geometryType);

                                return value ? Boolean.TRUE : Boolean.FALSE;

                        }

                })).booleanValue();

//                this.resourcesBegin();

//                try {

//                        return this.shpFile.canWriteGeometry(geometryType);

//

//                } finally {

//                        this.resourcesEnd();

//                }

        }

        public void performChanges(Iterator deleteds, Iterator inserteds,

                        Iterator updateds, Iterator originalFeatureTypesUpdated) throws PerformEditingException {

                final FeatureType fType;

                try {

                        fType = this.getStoreServices().getDefaultFeatureType();

                } catch (DataException e) {

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

                }

                // TODO Comprobar el campo de geometria

                final EditableFeatureType dbfFtype = fType.getEditable();

                removeGeometryColumn(dbfFtype);

                // try {

                // this.resourcesBegin();

                // } catch (ResourceExecuteException e1) {

                // throw new PerformEditingException(this.getName(), e1);

                // }

                try {

                        getResource().execute(new ResourceAction() {

                                public Object run() throws Exception {

                                        FeatureSet set = null;

                                        DisposableIterator iter = null;

                                        try {

                                                set = getFeatureStore().getFeatureSet();

                                                writer = new SHPFeatureWriter(getProviderName());

                                                SHPStoreParameters shpParams = getShpParameters();

                                                SHPStoreParameters tmpParams =

                                                                (SHPStoreParameters) shpParams.getCopy();

                                                File tmp_base = File.createTempFile(

                                                    "tmp_" + System.currentTimeMillis(), null);

                                                String str_base = tmp_base.getCanonicalPath();

                                                tmpParams.setDBFFile(str_base + ".dbf");

                                                tmpParams.setSHPFile(str_base + ".shp");

                                                tmpParams.setSHXFile(str_base + ".shx");

                                                writer.begin(tmpParams, fType, dbfFtype, set.getSize());

                                                iter = set.fastIterator();

                                                while (iter.hasNext()) {

                                                        Feature feature = (Feature) iter.next();

                                                        writer.append(feature);

                                                }

                                                writer.end();

                                                close();

                                                resourceCloseRequest();

                                                if (!shpParams.getDBFFile().delete()) {

                                                        throw new PerformEditingException(getProviderName(),

                                                                        new IOException(shpParams.getDBFFileName()));

                                                }

                                                if (!shpParams.getSHPFile().delete()) {

                                                        throw new PerformEditingException(getProviderName(),

                                                                        new IOException(shpParams.getSHPFileName()));

                                                }

                                                if (!shpParams.getSHXFile().delete()) {

                                                        throw new PerformEditingException(getProviderName(),

                                                                        new IOException(shpParams.getSHXFileName()));

                                                }

                                                if (!tmpParams.getDBFFile().renameTo(

                                                                shpParams.getDBFFile())) {

                                                    logger.info("Warning: copying tmp file instead of renaming: "

                                                        + shpParams.getDBFFile());

                                                    FileUtils.copyFile(

                                                        tmpParams.getDBFFile(),

                                                        shpParams.getDBFFile());

                                                }

                                                if (!tmpParams.getSHPFile().renameTo(

                                                                shpParams.getSHPFile())) {

                            logger.info("Warning: copying tmp file instead of renaming: "

                                + shpParams.getSHPFile());

                            FileUtils.copyFile(

                                tmpParams.getSHPFile(),

                                shpParams.getSHPFile());

                                                }

                                                if (!tmpParams.getSHXFile().renameTo(

                                                                shpParams.getSHXFile())) {

                            logger.info("Warning: copying tmp file instead of renaming: "

                                + shpParams.getSHXFile());

                            FileUtils.copyFile(

                                tmpParams.getSHXFile(),

                                shpParams.getSHXFile());

                                                }

                                                resourcesNotifyChanges();

                                                initFeatureType();

                                                return null;

                                        } finally {

                                                dispose(set);

                                                dispose(iter);

                                        }

                                }

                        });

                } catch (Exception e) {

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

                        // } finally {

                        // this.resourcesEnd();

                }

        }

        protected void resourceCloseRequest() throws ResourceException {

                // super.resourceCloseRequest();

                // this.shpResource.closeRequest();

                // this.shxResource.closeRequest();

                getResource().closeRequest();

        }

        public Envelope getEnvelope() throws DataException {

                this.open();

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

        }

        public void append(final FeatureProvider featureProvider) throws DataException {

//                this.resourcesBegin();

//                try {

                getResource().execute(new ResourceAction() {

                        public Object run() throws Exception {

                                writer.append(getStoreServices().createFeature(featureProvider));

                                return null;

                        }

                });

//                } finally {

//                        this.resourcesEnd();

//                }

        }

        public void beginAppend() throws DataException {

                // this.resourcesBegin();

                // try {

                getResource().execute(new ResourceAction() {

                        public Object run() throws Exception {

                                FeatureStore store = getFeatureStore();

                                FeatureType fType = store.getDefaultFeatureType();

                                // TODO Comprobar el campo de geometria

                                EditableFeatureType dbfFtype = fType.getEditable();

                                removeGeometryColumn(dbfFtype);

                                FeatureSet set = store.getFeatureSet();

                                writer = new SHPFeatureWriter(getProviderName());

                                writer.begin(getShpParameters(), fType, dbfFtype, set.getSize());

                                return null;

                        }

                });

                // } finally {

                // this.resourcesEnd();

                // }

        }

        public void endAppend() throws DataException {

//                this.resourcesBegin();

//                try {

                getResource().execute(new ResourceAction() {

                        public Object run() throws Exception {

                                writer.end();

                                resourcesNotifyChanges();

                                return null;

                        }

                });

//                } finally {

//                        this.resourcesEnd();

//                }

        }

        public Object getSourceId() {

                return this.getShpParameters().getFile();

        }

}