| gvSIG desktop 1

package org.gvsig.fmap.data.feature.file.shp;

import java.lang.ref.WeakReference;

import java.security.KeyException;

import java.util.Iterator;

import org.gvsig.exceptions.BaseException;

import org.gvsig.fmap.data.CloseException;

import org.gvsig.fmap.data.DataCollection;

import org.gvsig.fmap.data.DataException;

import org.gvsig.fmap.data.DataExplorer;

import org.gvsig.fmap.data.DataExplorerParameters;

import org.gvsig.fmap.data.DataManager;

import org.gvsig.fmap.data.DataStoreParameters;

import org.gvsig.fmap.data.InitializeException;

import org.gvsig.fmap.data.OpenException;

import org.gvsig.fmap.data.ReadException;

import org.gvsig.fmap.data.ResourceManager;

import org.gvsig.fmap.data.WriteException;

import org.gvsig.fmap.data.feature.AttributeDescriptor;

import org.gvsig.fmap.data.feature.DefaultFeatureType;

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

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

import org.gvsig.fmap.data.feature.FeatureCollection;

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

import org.gvsig.fmap.data.feature.FeaturesWriter;

import org.gvsig.fmap.data.feature.IsNotAttributeSettingException;

import org.gvsig.fmap.data.feature.file.FileExplorerParameters;

import org.gvsig.fmap.data.feature.file.dbf.DBFStore;

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

import org.gvsig.metadata.IMetadata;

import org.gvsig.metadata.IMetadataManager;

import org.gvsig.metadata.MetadataManager;

public class SHPStore extends DBFStore{

        public static String DATASTORE_NAME = "SHPStore";

        private SHPStoreParameters shpParameters=null;

        private SHPResource shp=null;

        public void init(DataStoreParameters parameters) throws InitializeException {

                super.init(parameters);

                defaultFeatureType=super.getDefaultFeatureType();

                AttributeDescriptor dad=(AttributeDescriptor) ((DefaultFeatureType)defaultFeatureType).createAttributeDescriptor();

                try {

                        dad.loading();

                        dad.setName("GEOMETRY");

                        dad.setType(FeatureAttributeDescriptor.TYPE_GEOMETRY);

                        dad.stopLoading();

                } catch (IsNotAttributeSettingException e1) {

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

                }

                defaultFeatureType.add(dad);

                defaultFeatureType.setDefaultGeometry("GEOMETRY");

                this.shpParameters=(SHPStoreParameters)parameters;

                SHPResource tmpResource = new SHPResource(this.shpParameters);

                ResourceManager resMan = ResourceManager.getResourceManager();

                 try {

                         this.shp = (SHPResource)resMan.addResource(tmpResource);

                 } catch (DataException e1) {

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

                 }

                try {

                        defaultFeatureType.setGeometryTypes(new int[]{this.shp.getGeometryType()});

                } catch (ReadException e) {

                        throw new InitializeException("Can't read type",this.getName(),e);

                }

                 this.observeResource(this.shp);

        }

        protected void doFinishEdition() throws WriteException, ReadException {

                this.shp.editing();

                super.doFinishEdition();

                this.shp.stopEditing();

                this.shp.changed(this);

        }

        public DataCollection getDataCollection(FeatureType type, String filter, String order) throws ReadException {

                if (type==null){

                        type=getDefaultFeatureType();

                }

                FeatureCollection coll;

                if (order == null){

                        if (featureManager==null){

                                coll=new SHPFeatureCollectionBitSet(this,type,filter);

                        }else{

                                coll=new ShpFeatureCollection(featureManager,this,type,filter);

                        }

                }else{

                        coll=new ShpFeatureCollectionWithFeatureID(featureManager,this,type,filter,order);

                }

                this.addObserver(new WeakReference(coll));

                return coll;

        }

        /**

         *

         * NOT supported in Alter Mode

         *

         * @param index

         * @param featureType

         * @return

         * @throws ReadException

         */

        protected Feature getFeatureByIndex(long index, FeatureType featureType)

                        throws ReadException {

                if (index >= this.getFeatureCount()) {

                        throw new ReadException(this.getName(),

                                        "Unsupported operation for not persistented features");

                }

                ShpFeature feature = new ShpFeature(featureType, this, index);

                return feature;

        }

        public boolean isWithDefaultLegend() {

                return false;

        }

        public Object getDefaultLegend() {

                return null;

        }

        public Object getDefaultLabelingStrategy() {

                return null;

        }

        public boolean canAlterFeatureType() {

                return true;

        }

        public String getName() {

                return DATASTORE_NAME;

        }

        protected void doOpen() throws OpenException {

                super.doOpen();

        }

        protected void doClose() throws CloseException {

                super.doClose();

                try {

                        this.shp.close();

                } catch (DataException e) {

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

                }

        }

        protected void doDispose() throws CloseException {

                super.doDispose();

                ResourceManager resMan = ResourceManager.getResourceManager();

            try {

                        resMan.remove(this.shp);

                } catch (DataException e1) {

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

                } catch (KeyException e) {

                        // TODO Auto-generated catch block

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

                }

                this.shp = null;

                this.metadata=null;

        }

        public boolean isEditable() {

                if (super.isEditable() && this.shp.isEditable()) {

                        return true;

                }

                return false;

        }

        public IMetadata getMetadata() throws BaseException {

                if (metadata==null){

                        IMetadataManager manager=MetadataManager.getManager();

                        metadata=manager.create(DATASTORE_NAME);

                        Envelope extent=this.shp.getFullExtent();

                        metadata.set("extent",extent);

                        String srs=this.shp.getSRS();

                        metadata.set("srs",srs);

                }

                if (this.alterMode){

                        Envelope extent=null;

                        FeatureCollection featureCollection=(FeatureCollection)getDataCollection();

                        if (spatialManager.isFullExtentDirty()){

                                if (!featureCollection.isEmpty()){

                                        Iterator featureIterator=featureCollection.iterator();

                                        while(featureIterator.hasNext()){

                                                if (extent==null){

                                                        extent = ((Feature)featureIterator.next()).getExtent();

                                                }else{

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

                                                        Envelope boundExtent=feature.getExtent();

                                                        if (boundExtent!=null) {

                                                                extent.add(boundExtent);

                                                        }

                                                }

                                        }

                                }

                                metadata.set("extent",extent);

                        }

                }

                return metadata;

        }

//        protected Feature getFeatureByPosition(FeatureType featureType,long position) throws ReadException {

//        ShpFeature feature=new ShpFeature(featureType,this,position);

//        feature.load(dbf, this.getGeometry(position));

//        return feature;

//        }

        protected FeaturesWriter getFeaturesWriter() {

                FeaturesWriter writer = new ShpFeaturesWriter();

//                writer.init(this);

                return writer;

        }

        protected long getFeatureCount() throws ReadException{

                return super.getFeatureCount();

        }

        public DataExplorer getExplorer() throws InitializeException {

                DataManager dsm=DataManager.getManager();

                DataExplorerParameters dsp = dsm.createDataExplorerParameters(

                                SHPDataExplorer.DATASOURCE_NAME);

                ((FileExplorerParameters)dsp).setSource(shpParameters.getFile().getParentFile());

                DataExplorer src=null;

                try {

                        src = dsm.createDataExplorer(dsp);

                } catch (InitializeException e1) {

                        e1.printStackTrace();

                }

                return src;

        }

        /* (non-Javadoc)

         * @see org.gvsig.fmap.data.feature.file.dbf.DBFStore#doRefresh()

         */

        protected void doRefresh() throws OpenException, InitializeException {

                // TODO Auto-generated method stub

                super.doRefresh();

        }

        /**

         * @param featureIndex

         * @return

         * @throws ReadException

         */

        protected Envelope getBoundingBox(long featureIndex) throws ReadException {

                return this.shp.getBoundingBox(featureIndex);

        }

        /**

         * @param featureIndex

         * @return

         * @throws ReadException

         */

        protected Object getGeometry(long featureIndex) throws ReadException {

                return this.shp.getGeometry(featureIndex);

        }

}