Application: gvSIG desktop

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

import java.lang.ref.WeakReference;

import java.security.KeyException;

import java.util.ArrayList;

import java.util.Collection;

import java.util.Comparator;

import java.util.Iterator;

import java.util.TreeSet;

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

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

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

import org.gvsig.fmap.data.feature.expressionevaluator.Filter;

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

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

import org.gvsig.fmap.geom.Geometry;

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

import org.gvsig.metadata.IMetadata;

import org.gvsig.metadata.IMetadataManager;

import org.gvsig.metadata.MetadataManager;

import org.gvsig.tools.exception.BaseException;

public class DGNStore extends FileStore{

        public static String DATASTORE_NAME = "DGNStore";

        protected IMetadata metadata;

        private DGNStoreParameters dgnParameters=null;

        private DGNResource dgn;

        public void init(DataStoreParameters parameters) throws InitializeException {

                dgnParameters=(DGNStoreParameters)parameters;

                try {

                        DGNResource tmpResource = new DGNResource(dgnParameters);

                        ResourceManager resMan = ResourceManager.getResourceManager();

                        try {

                                this.dgn = (DGNResource) resMan.addResource(tmpResource, this);

                        } catch (DataException e1) {

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

                        }

                        super.init(parameters, this.dgn);

                        this.defaultFeatureType = this.dgn.getFeatureType();

                        this.featureTypes = new ArrayList();

                        this.featureTypes.add(defaultFeatureType);

                } catch (ReadException e) {

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

                } catch (DataException e) {

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

                }

        }

        static FeatureType newFeatureType() throws DataException{

                DefaultFeatureType fType= new DefaultFeatureType();

                AttributeDescriptor descriptorID = (AttributeDescriptor) fType.createAttributeDescriptor();

                descriptorID.loading();

                descriptorID.setType(FeatureAttributeDescriptor.TYPE_INT);

                descriptorID.setName("ID");

                descriptorID.setDefaultValue(new Integer(0));

                descriptorID.stopLoading();

                fType.add(descriptorID);

                fType.setFieldsId(new String[] {"ID"});

                AttributeDescriptor descriptorEntity = (AttributeDescriptor) fType.createAttributeDescriptor();

                descriptorEntity.loading();

                descriptorEntity.setType(FeatureAttributeDescriptor.TYPE_STRING);

                descriptorEntity.setName("Entity");

                descriptorEntity.setDefaultValue("Entity");

                descriptorEntity.stopLoading();

                fType.add(descriptorEntity);

                AttributeDescriptor descriptorLayer = (AttributeDescriptor) fType.createAttributeDescriptor();

                descriptorLayer.loading();

                descriptorLayer.setType(FeatureAttributeDescriptor.TYPE_INT);

                descriptorLayer.setName("Layer");

                descriptorLayer.setDefaultValue(new Integer(0));

                descriptorLayer.stopLoading();

                fType.add(descriptorLayer);

                AttributeDescriptor descriptorColor = (AttributeDescriptor) fType.createAttributeDescriptor();

                descriptorColor.loading();

                descriptorColor.setType(FeatureAttributeDescriptor.TYPE_INT);

                descriptorColor.setName("Color");

                descriptorColor.setDefaultValue(new Integer(0));

                descriptorColor.stopLoading();

                fType.add(descriptorColor);

                //                DefaultAttributeDescriptor descriptorElevation = new DefaultAttributeDescriptor();

                //                descriptorElevation.setType(FeatureAttributeDescriptor.TYPE_DOUBLE);

                //                descriptorElevation.setName("Elevation");

                //                descriptorElevation.setDefaultValue(new Double(0));

                //                featureType.add(descriptorElevation);

                //

                //                DefaultAttributeDescriptor descriptorThickness = new DefaultAttributeDescriptor();

                //                descriptorThickness.setType(FeatureAttributeDescriptor.TYPE_DOUBLE);

                //                descriptorThickness.setName("Thickness");

                //                descriptorThickness.setDefaultValue(new Double(0));

                //                featureType.add(descriptorThickness);

                AttributeDescriptor descriptorHeightText = (AttributeDescriptor) fType.createAttributeDescriptor();

                descriptorHeightText.loading();

                descriptorHeightText.setType(FeatureAttributeDescriptor.TYPE_FLOAT);

                descriptorHeightText.setName("HeightText");

                descriptorHeightText.setDefaultValue(new Float(0));

                descriptorHeightText.stopLoading();

                fType.add(descriptorHeightText);

                AttributeDescriptor descriptorRotationText = (AttributeDescriptor) fType.createAttributeDescriptor();

                descriptorRotationText.loading();

                descriptorRotationText.setType(FeatureAttributeDescriptor.TYPE_DOUBLE);

                descriptorRotationText.setName("RotationText");

                descriptorRotationText.setDefaultValue(new Double(0));

                descriptorRotationText.stopLoading();

                fType.add(descriptorRotationText);

                AttributeDescriptor descriptorText = (AttributeDescriptor) fType.createAttributeDescriptor();

                descriptorText.loading();

                descriptorText.setType(FeatureAttributeDescriptor.TYPE_STRING);

                descriptorText.setName("Text");

                descriptorText.setDefaultValue("");

                descriptorText.stopLoading();

                fType.add(descriptorText);

                AttributeDescriptor descriptorShape = (AttributeDescriptor) fType.createAttributeDescriptor();

                descriptorShape.loading();

                descriptorShape.setType(FeatureAttributeDescriptor.TYPE_GEOMETRY);

                descriptorShape.setName("GEOMETRY");

                descriptorShape.setDefaultValue(null);

                descriptorShape.stopLoading();

                fType.add(descriptorShape);

                fType.setDefaultGeometry("GEOMETRY");

                fType.setGeometryTypes(new int[]{Geometry.TYPES.GEOMETRY});

                return fType;

        }

        protected void doFinishEdition() throws WriteException, ReadException{

        }

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

                try {

                        type = this.checkFeatureTypeForCollection(type);

                } catch (DataException e) {

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

                }

                FeatureCollection coll;

                DataManager manager = DataManager.getManager();

                //TODO aplicar filtro, orden e incluso y el featureType

                Filter parser = null;

                if (filter!=null){

                        parser = manager.getExpressionParser().parseFilter(filter);

                }

//                ArrayList originalFeatures=this.getFeatures();

                int num=0;

                if (featureManager!=null){

                        num=featureManager.getNum();

                }

                int originalSize=this.dgn.getFeatureCount();

                Collection allFeatures = null;

                if (order!=null){

                        Comparator comparator = manager.getExpressionParser()

                                        .parseComparator(order);

                        allFeatures = new TreeSet(comparator);

                }else{

                        allFeatures=new ArrayList();

                }

//                int j=0;

                for (int i = 0; i < originalSize+num; i++) {

                        Feature feature=null;

                        if (i<this.dgn.getFeatureCount()){

                                feature=this.dgn.getFeature(i);

                        }else{

                                feature=featureManager.getFeature(i-originalSize,this,type);

                        }

                        if (featureManager == null || !featureManager.isDeleted(feature)){

                                if (filter == null || parser.evaluate(feature)) {

//                                        System.err.println(i);

//                                        j++;

//                                        System.err.println("j= "+j);

                                        if (!allFeatures.add(feature)) {

                                                //????

//                                                System.err.println("Fallo  " +auxfeature);

                                        }else{

//                                                System.out.println("Correcto  " +auxfeature);

                                        }

                                }

                        }

                }

                coll = new DGNFeatureCollection(this, type, allFeatures);

                this.addObserver(new WeakReference(coll));

                return coll;

        }

        public Feature getFeatureByID(FeatureID id,FeatureType featureType) throws ReadException {

                if (featureType==null){

                        featureType=getDefaultFeatureType();

                }else{

                        if (!featureType.isSubtypeOf(this.getDefaultFeatureType())){

                                throw new ReadException("invalid type",this.getName());

                        }

                }

                if (this.alterMode){

                        if (featureManager.contains(id)) {

                                return featureManager.getFeature(id,this,featureType);

                        }

                }

                return id.getFeature(featureType);

        }

        public Object getDefaultLegend() throws ReadException {

                return this.dgn.getDefaultLegend();

        }

        public boolean canAlterFeatureType() {

                return false;

        }

        public String getName() {

                return DATASTORE_NAME;

        }

        protected void doOpen() throws OpenException {

        }

        protected void doClose() throws CloseException {

                this.dgn.close();

        }

        protected void doDispose() throws CloseException {

                super.doDispose();

                ResourceManager resMan = ResourceManager.getResourceManager();

            try {

                        resMan.remove(this.dgn, this);

                } catch (DataException e1) {

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

                } catch (KeyException e) {

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

                }

                this.dgn = null;

                this.defaultFeatureType=null;

                this.metadata=null;

        }

        public boolean isEditable() {

                return false;

        }

        public IMetadata getMetadata() throws BaseException {

                if (metadata==null){

                        IMetadataManager manager=MetadataManager.getManager();

                        metadata=manager.create(DATASTORE_NAME);

                        Envelope extent=this.dgn.getFullExtent();

                        metadata.set("extent",extent);

                        String srs=getSRS();

                        metadata.set("srs",srs);

                        metadata.set("WithDefaultLegend", Boolean.TRUE);

                }

                if (this.alterMode){

                        Envelope extent=(Envelope)metadata.get("extent");

                        FeatureCollection featureCollection=(FeatureCollection)getDataCollection();

                        if (spatialManager.isFullExtentDirty()){

                                if (!featureCollection.isEmpty()){

                                        Iterator featureIterator=featureCollection.iterator();

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

                                        while(featureIterator.hasNext()){

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

                                                Envelope boundExtent=feature.getExtent();

                                                if (boundExtent!=null) {

                                                        extent.add(boundExtent);

                                                }

                                        }

                                }

                        }

                        metadata.set("extent",extent);

                }

                return metadata;

        }

        private String getSRS() {

                // TODO Auto-generated method stub

                return null;

        }

        protected FeaturesWriter getFeaturesWriter() {

                return null;

        }

        public DataStoreParameters getParameters() {

                return parameters;

        }

        public DataExplorer getExplorer() throws InitializeException {

                DataManager dsm=DataManager.getManager();

                DataExplorerParameters dsp = dsm.createDataExplorerParameters(

                                DGNDataExplorer.DATASOURCE_NAME);

                ((FileExplorerParameters)dsp).setSource(dgnParameters.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.FeatureStore#doRefresh()

         */

        protected void doRefresh() throws OpenException, InitializeException {

                // TODO Auto-generated method stub

        }

        public boolean canWriteGeometry(int gvSIGgeometryType) {

                return false;

        }

        public Object getDefaultLabelingStrategy() throws ReadException {

                return this.dgn.getDefaultLabelingStrategy();

        }

}