| gvSIG desktop 1

/* 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):

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

*/

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

import java.io.IOException;

import java.util.Iterator;

import org.gvsig.fmap.dal.DataTypes;

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

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

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

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

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

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

import org.gvsig.fmap.dal.feature.impl.DefaultFeatureType;

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

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

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

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

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

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

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

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dynobject.DelegatedDynObject;

import org.gvsig.tools.dynobject.DynClass;

import org.gvsig.tools.dynobject.DynField;

import org.gvsig.tools.dynobject.DynObjectManager;

import org.gvsig.tools.persistence.PersistenceException;

import org.gvsig.tools.persistence.PersistentState;

public class SHPStoreProvider extends DBFStoreProvider {

        public static String NAME = "SHPStore";

        public static String DESCRIPTION = "SHP file";

        private SHPFile shpFile;

        private ResourceProvider shpResource;

        private ResourceProvider shxResource;

        private SHPStoreParameters shpParams;

        protected static final String GEOMETRY_ATTIBUTE_NAME = "GEOMETRY";

        protected static final String DYNFIELD_SRSORIGINALPARAMETERS_NAME = "SRSOriginalParameters";

        private static final String DYNCLASS_NAME = "SHPStore";

        protected static DynClass DYNCLASS = null;

        private SHPFeatureWriter writer = null;

        public SHPStoreProvider(SHPStoreParameters params)

                        throws InitializeException {

                super(params);

                this.shpParams = params;

                shpResource = this.createResource(FileResource.NAME,

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

                shpResource.addConsumer(this);

                shxResource = this.createResource(FileResource.NAME,

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

                shxResource.addConsumer(this);

                // FIXME

                this.dynObject = (DelegatedDynObject) ToolsLocator

                                .getDynObjectManager().createDynObject(DYNCLASS);

                this.shpFile = new SHPFile(this.shpParams);

        }

        private void resourcesBegin() throws ResourceBeginException {

                this.shpResource.begin();

                this.shxResource.begin();

        }

        private void resourcesEnd() {

                this.shpResource.end();

                this.shxResource.end();

        }

        /**

         *

         * @throws ResourceNotifyChangesException

         */

        private void resourcesNotifyChanges() throws ResourceNotifyChangesException {

                this.shpResource.notifyChanges();

                this.shxResource.notifyChanges();

        }

        /**

         * @throws ResourceNotifyCloseException

         *

         */

        private void resourcesNotifyClose() throws ResourceNotifyCloseException {

                this.shpResource.notifyClose();

                this.shxResource.notifyClose();

        }

        /**

         * @throws ResourceNotifyOpenException

         *

         */

        private void resourcesOpen() throws ResourceNotifyOpenException {

                this.shpResource.notifyOpen();

                this.shxResource.notifyOpen();

        }

        protected static void registerDynClass() {

                DynObjectManager dynman = ToolsLocator.getDynObjectManager();

                DynClass dynClass;

                DynField field;

                if (DYNCLASS == null) {

                        DynClass dbfDynClass = DBFStoreProvider.DYNCLASS;

                        dynClass = dynman.add(DYNCLASS_NAME);

                        field = dynClass.addDynField(DYNFIELD_SRSORIGINALPARAMETERS_NAME);

                        field.setType(DataTypes.STRING);

                        field.setDescription("SRS original parameters");

            // The SHP store parameters extend the DBF store parameters

                        dynClass.extend(dbfDynClass);

                        DYNCLASS = dynClass;

                }

        }

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

                        attr.setDefaultValue(new NullGeometry());

                }

                fType.setDefaultGeometryAttributeName(attr.getName());

                return attr;

        }

        protected static void removeGeometryColumn(

                        EditableFeatureType fType) {

                Iterator iter = fType.iterator();

                FeatureAttributeDescriptor attr;

                while (iter.hasNext()) {

                        attr = (FeatureAttributeDescriptor) iter.next();

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

                                iter.remove();

                        }

                }

                fType.setDefaultGeometryAttributeName(null);

                fType.remove(GEOMETRY_ATTIBUTE_NAME);

        }

        protected EditableFeatureType getTheFeatureType()

                        throws InitializeException {

                EditableFeatureType fType = super.getTheFeatureType();

                try {

                        this.open();

                        this.resourcesBegin();

                } catch (DataException e) {

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

                }

                try {

                        EditableFeatureAttributeDescriptor attr = addGeometryColumn(

                                        fType).setGeometryType(

                                        this.shpFile.getGeometryType());

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

                        if (srs == null){

                                // TODO petar ??

                                srs = "EPSG:23030";

                        }

                        attr.setSRS(srs);

                        return fType;

                } catch (ReadException e) {

                        throw new InitializeException(e);

                } finally {

                        this.resourcesEnd();

                }

        }

        private String getSRS(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 shpParams;

        }

        public String getName() {

                return NAME;

        }

        public boolean allowWrite() {

                return super.allowWrite() && this.shpFile.isEditable();

        }

        /**

         *

         * @param index

         * @param featureType

         * @return

         * @throws ReadException

         */

        protected FeatureData getFeatureDataByIndex(long index,

                        FeatureType featureType) throws DataException {

                this.open();

                this.resourcesBegin();

                try {

                        FeatureData featureData = super.getFeatureDataByIndex(index,

                                        featureType);

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

                        return featureData;

                } catch (DataException e) {

                        throw e;

                } finally {

                        this.resourcesEnd();

                }

        }

        protected void initFeatureDataByIndex(FeatureData featureData,

                        long index, FeatureType featureType) throws DataException {

                this.open();

                this.resourcesBegin();

                try {

                        super.initFeatureDataByIndex(featureData, index, featureType);

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

                } finally {

                        this.resourcesEnd();

                }

        }

        /**

         *

         * @param featureData

         * @throws DataException

         */

        protected void loadFeatureDataByIndex(FeatureData featureData)

                        throws DataException {

                this.open();

                this.resourcesBegin();

                try {

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

                        super.loadFeatureDataByIndex(featureData);

                        if (featureData.getType().getIndex(

                                        featureData.getType().getDefaultGeometryAttributeName()) >= 0) {

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

                        }

                } finally {

                        this.resourcesEnd();

                }

        }

        protected void loadValue(FeatureData featureData, int rowIndex,

                        FeatureAttributeDescriptor descriptor) throws ReadException {

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

                        return;

                } else {

                        super.loadValue(featureData, rowIndex, descriptor);

                }

        }

        public FeatureData createFeatureData(FeatureType type) throws DataException {

                FeatureData data = new SHPFeatureData(this, (DefaultFeatureType) type);

                return data;

        }

        public void open() throws OpenException {

                super.open();

                if (this.shpFile.isOpen()) {

                        return;

                }

                try {

                        this.resourcesBegin();

                } catch (ResourceBeginException e) {

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

                }

                try {

                        this.shpFile.open();

                        this.resourcesOpen();

                        // load metadata

                        //                        TODO: Load .prj data

                        //                        this.dynObject.setDynValue(

                        //                                        DYNFIELD_SRSORIGINALPARAMETERS_NAME,

                        //                                        this.shpFile.??);

                        this.dynObject.setDynValue("DefaultSRS", this.shpFile

                                        .getSRSParameters());

                        this.dynObject.setDynValue("Envelope", shpFile.getFullExtent());

                } catch (UnsupportedVersionException e) {

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

                } catch (ResourceNotifyOpenException e) {

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

                } catch (FileNotFoundException e) {

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

                } catch (DataException e) {

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

                } finally {

                        this.resourcesEnd();

                }

        }

        public void close() throws CloseException {

                super.close();

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

                        return;

                }

                try {

                        this.resourcesBegin();

                } catch (ResourceBeginException e) {

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

                }

                try {

                        this.shpFile.close();

                        this.resourcesNotifyClose();

                } catch (ResourceNotifyCloseException e) {

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

                } finally {

                        this.resourcesEnd();

                }

        }

        public boolean canWriteGeometry(int geometryType) throws DataException {

                this.open();

                this.resourcesBegin();

                try {

                        return this.shpFile.canWriteGeometry(geometryType);

                } finally {

                        this.resourcesEnd();

                }

        }

        public void performEditing(Iterator deleteds, Iterator inserteds,

                        Iterator updateds) throws PerformEditingException {

                FeatureType fType;

                try {

                        fType = this.store.getDefaultFeatureType();

                } catch (DataException e) {

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

                }

                // TODO Comprobar el campo de geometria

                EditableFeatureType dbfFtype = fType.getEditable();

                removeGeometryColumn(dbfFtype);

                try {

                        this.resourcesBegin();

                        this.getDBFResource().begin();

                } catch (ResourceBeginException e1) {

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

                }

                try {

                        FeatureSet set = this.store.getFeatureSet();

                        writer = new SHPFeatureWriter(this.getName());

                        SHPStoreParameters tmpParams = (SHPStoreParameters) this.shpParams

                                        .getCopy();

                        tmpParams.setDBFFileName(tmpParams.getDBFFileName() + ".tmp");

                        tmpParams.setSHPFileName(tmpParams.getSHPFileName() + ".tmp");

                        tmpParams.setSHXFileName(tmpParams.getSHXFileName() + ".tmp");

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

                        Iterator iter = set.iterator();

                        while (iter.hasNext()) {

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

                                writer.append(feature);

                        }

                        writer.end();

                        this.close();

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

                                throw new PerformEditingException(this.getName(),

                                                new IOException(this.shpParams.getDBFFileName()));

                        }

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

                                throw new PerformEditingException(this.getName(),

                                                new IOException(this.shpParams.getSHPFileName()));

                        }

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

                                throw new PerformEditingException(this.getName(),

                                                new IOException(this.shpParams.getSHXFileName()));

                        }

                        if (!tmpParams.getDBFFile().renameTo(this.shpParams.getDBFFile())) {

                                throw new PerformEditingException(this.getName(),

                                                new IOException(this.shpParams.getSHPFileName()));

                        }

                        if (!tmpParams.getSHPFile().renameTo(this.shpParams.getSHPFile())) {

                                throw new PerformEditingException(this.getName(),

                                                new IOException(this.shpParams.getSHPFileName()));

                        }

                        if (!tmpParams.getSHXFile().renameTo(this.shpParams.getSHXFile())) {

                                throw new PerformEditingException(this.getName(),

                                                new IOException(this.shpParams.getSHXFileName()));

                        }

                        this.resourcesNotifyChanges();

                        this.getDBFResource().notifyChanges();

                } catch (Exception e) {

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

                } finally {

                        this.resourcesEnd();

                        this.getDBFResource().end();

                }

        }

        public Envelope getEnvelope() throws DataException {

                this.open();

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

        }

        public void setState(PersistentState state) throws PersistenceException {

                // TODO Auto-generated method stub

                super.setState(state);

        }

        public PersistentState getState() throws PersistenceException {

                // TODO Auto-generated method stub

                return super.getState();

        }

        public void append(Feature feature) throws DataException {

                this.resourcesBegin();

                try {

                        writer.append(feature);

                } finally {

                        this.resourcesEnd();

                }

        }

        public void beginAppend() throws DataException {

                this.resourcesBegin();

                try {

                        FeatureType fType = this.store.getDefaultFeatureType();

                        // TODO Comprobar el campo de geometria

                        EditableFeatureType dbfFtype = fType.getEditable();

                        removeGeometryColumn(dbfFtype);

                        FeatureSet set = this.store.getFeatureSet();

                        writer = new SHPFeatureWriter(this.getName());

                        writer.begin(this.shpParams, fType, dbfFtype, set.getSize());

                } finally {

                        this.resourcesEnd();

                }

        }

        public void endAppend() throws DataException {

                this.resourcesBegin();

                try {

                        writer.end();

                        this.resourcesNotifyChanges();

                } finally {

                        this.resourcesEnd();

                }

        }

        /*

         * (non-Javadoc)

         *

         * @see org.gvsig.metadata.Metadata#getMetadataName()

         */

        public String getMetadataName() {

                return this.shpParams.getSHPFile().getName();

        }

}