Application: gvSIG desktop

package org.gvsig.data.datastores.vectorial.file.dxf;

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

import java.util.TreeSet;

import org.gvsig.data.CloseException;

import org.gvsig.data.DataCollection;

import org.gvsig.data.DataException;

import org.gvsig.data.DataExplorer;

import org.gvsig.data.DataExplorerParameters;

import org.gvsig.data.DataManager;

import org.gvsig.data.DataStoreParameters;

import org.gvsig.data.InitializeException;

import org.gvsig.data.OpenException;

import org.gvsig.data.ReadException;

import org.gvsig.data.ResourceManager;

import org.gvsig.data.WriteException;

import org.gvsig.data.datastores.vectorial.FeaturesWriter;

import org.gvsig.data.datastores.vectorial.file.FileExplorerParameters;

import org.gvsig.data.vectorial.AbstractFeatureStore;

import org.gvsig.data.vectorial.AttributeDescriptor;

import org.gvsig.data.vectorial.DefaultFeatureType;

import org.gvsig.data.vectorial.Feature;

import org.gvsig.data.vectorial.FeatureAttributeDescriptor;

import org.gvsig.data.vectorial.FeatureCollection;

import org.gvsig.data.vectorial.FeatureID;

import org.gvsig.data.vectorial.FeatureType;

import org.gvsig.data.vectorial.IsNotAttributeSettingException;

import org.gvsig.data.vectorial.IsNotFeatureSettingException;

import org.gvsig.data.vectorial.MemoryFeature;

import org.gvsig.data.vectorial.expressionevaluator.FeatureComparator;

//import org.gvsig.data.vectorial.expressionevaluator.FeatureFilter;

import org.gvsig.exceptions.BaseException;

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

import org.gvsig.metadata.IMetadata;

import org.gvsig.metadata.IMetadataManager;

import org.gvsig.metadata.MetadataManager;

import org.opengis.filter.Filter;

import org.opengis.filter.sort.SortBy;

public class DXFStore extends AbstractFeatureStore{

        public static String DATASTORE_NAME = "DXFStore";

        private List featureTypes = new ArrayList();

        protected IMetadata metadata;

        private DXFStoreParameters dxfParameters;

        private DXFResource dxf;

        public void init(DataStoreParameters parameters) throws InitializeException {

                dxfParameters=(DXFStoreParameters)parameters;

                DXFResource tmpResource = new DXFResource(dxfParameters);

                ResourceManager resMan = ResourceManager.getResourceManager();

                try {

                        this.dxf = (DXFResource)resMan.addResource(tmpResource);

                } catch (DataException e1) {

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

                }

                super.init(parameters,this.dxf);

                try {

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

                } catch (ReadException e) {

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

                }

        }

         static FeatureType newFeatureType(){

                        DefaultFeatureType fType= new DefaultFeatureType();

                        try{

                        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);

                        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");

                        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_STRING);

                        descriptorLayer.setName("Layer");

                        descriptorLayer.setDefaultValue("default");

                        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);

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

                        descriptorElevation.loading();

                        descriptorElevation.setType(FeatureAttributeDescriptor.TYPE_DOUBLE);

                        descriptorElevation.setName("Elevation");

                        descriptorElevation.setDefaultValue(new Double(0));

                        descriptorElevation.stopLoading();

                        fType.add(descriptorElevation);

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

                        descriptorThickness.loading();

                        descriptorThickness.setType(FeatureAttributeDescriptor.TYPE_DOUBLE);

                        descriptorThickness.setName("Thickness");

                        descriptorThickness.setDefaultValue(new Double(0));

                        descriptorThickness.stopLoading();

                        fType.add(descriptorThickness);

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

                        descriptorText.loading();

                        descriptorText.setType(FeatureAttributeDescriptor.TYPE_STRING);

                        descriptorText.setName("Text");

                        descriptorText.setDefaultValue("");

                        descriptorText.stopLoading();

                        fType.add(descriptorText);

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

                        descriptorHeightText.loading();

                        descriptorHeightText.setType(FeatureAttributeDescriptor.TYPE_FLOAT);

                        descriptorHeightText.setName("HeightText");

                        descriptorHeightText.setDefaultValue(new Float(10));

                        descriptorHeightText.stopLoading();

                        fType.add(descriptorHeightText);

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

                        descriptorRotationText.loading();

                        descriptorRotationText.setType(FeatureAttributeDescriptor.TYPE_DOUBLE);

                        descriptorRotationText.setName("Rotation");

                        descriptorRotationText.setDefaultValue(new Double(10));

                        descriptorRotationText.stopLoading();

                        fType.add(descriptorRotationText);

                        }catch (IsNotAttributeSettingException e) {

                                e.printStackTrace();

                        }

                        return fType;

         }

        protected void doFinishEdition() throws WriteException, ReadException {

                FeaturesWriter writer = getFeaturesWriter();

        writer.init(this);

        writer.updateFeatureType(defaultFeatureType);

        this.dxf.editing();

        writer.preProcess();

        Collection collection=getDataCollection();

        Iterator iterator=collection.iterator();

        Feature feature;

        while (iterator.hasNext()) {

                feature= (Feature) iterator.next();

                        writer.insertFeature(feature);

                }

        writer.postProcess();

        this.dxf.stopEditing();

        this.dxf.changed(this);

        }

        public DataCollection getDataCollection(FeatureType type, Filter filter, SortBy[] order) throws ReadException {

                if (type==null){

                        type=getDefaultFeatureType();

                } else {

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

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

                        }

                }

                FeatureCollection coll;

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

                /*FeatureFilter parser = null;

                if (filter!=null){

                        parser = new FeatureFilter(filter,type);

                }*/

//                ArrayList originalFeatures=this.dxf.getFeatures();

                int num=0;

                if (featureManager!=null){

                        num=featureManager.getNum();

                }

                int originalSize=this.dxf.getFeatureCount();

                Collection allFeatures=null;

                if (order!=null){

                        Comparator comparator = new FeatureComparator(type,order);

                        allFeatures = new TreeSet(comparator);

                }else{

                        allFeatures=new ArrayList();

                }

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

                        Feature feature=null;

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

                                feature=this.dxf.getFeature(i);

                        }else{

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

                        }

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

                                try {

                                                MemoryFeature auxfeature=new DXFFeature(type,false);

                                                auxfeature.loading();

//                                                auxfeature.setDefaultGeometry(feature.getDefaultGeometry());

                                                Iterator iterator=type.iterator();

                                                while (iterator.hasNext()) {

                                                        FeatureAttributeDescriptor fad = (FeatureAttributeDescriptor) iterator.next();

                                                        int index=((AttributeDescriptor)fad).originalPosition();

                                                        if (fad.getDataType().equals(FeatureAttributeDescriptor.TYPE_GEOMETRY)){

                                                                auxfeature.setGeometry(index,feature.get(index));

                                                        } else {

                                                                auxfeature.set(index,feature.get(index));

                                                        }

                                                }

                                                if (filter==null || filter.evaluate(auxfeature)){

                                                        allFeatures.add(auxfeature);

                                                }

                                                auxfeature.stopLoading();

                                } catch (IsNotFeatureSettingException e) {

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

                                }

                        }

                }

                coll=new DXFFeatureCollection(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 List getFeatureTypes() {

                featureTypes.set(0,getDefaultFeatureType());

        return featureTypes;

        }

        public boolean isWithDefaultLegend() {

                return false;

        }

        public Object getDefaultLegend() {

                return null;

        }

        public Object getDefaultLabelingStrategy() {

                return null;

        }

        public boolean canAlterFeatureType() {

                return false;

        }

        public String getName() {

                return DATASTORE_NAME;

        }

        protected void doOpen() throws OpenException {

        }

        protected void doClose() throws CloseException {

                this.dxf.close();

        }

        protected void doDispose() throws CloseException {

                super.doDispose();

                ResourceManager resMan = ResourceManager.getResourceManager();

            try {

                        resMan.remove(this.dxf);

                } catch (DataException e1) {

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

                } catch (KeyException e) {

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

                }

                this.dxf = null;

                this.defaultFeatureType=null;

                this.metadata=null;

        }

        public boolean isEditable() {

                return this.dxf.isEditable();

        }

        public IMetadata getMetadata() throws BaseException {

                if (metadata==null){

                        IMetadataManager manager=MetadataManager.getManager();

                        metadata=manager.create(DATASTORE_NAME);

                        Envelope extent=this.dxf.getFullExtent();

                        metadata.set("extent",extent);

                        String srs=getSRS();

                        metadata.set("srs",srs);

                }

                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() {

                FeaturesWriter writer = new DXFFeaturesWriter();

//                writer.init(this);

                return writer;

        }

        public DataStoreParameters getParameters() {

                return parameters;

        }

        public DataExplorer getExplorer() {

                DataManager dsm=DataManager.getManager();

                DataExplorerParameters dsp = dsm.createDataExplorerParameters(

                                DXFDataExplorer.DATASOURCE_NAME);

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

                DataExplorer src=null;

                try {

                        src = dsm.createDataExplorer(dsp);

                } catch (InitializeException e1) {

                        e1.printStackTrace();

                }

                return src;

        }

        /* (non-Javadoc)

         * @see org.gvsig.data.vectorial.FeatureStore#doRefresh()

         */

        protected void doRefresh() throws OpenException, InitializeException {

                // TODO Auto-generated method stub

        }

}