/ - Diff - | gvSIG desktop 1 - gvSIG

     /* 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):
     * 2009 {Iver T.I.}   {Task}
     */
     package org.gvsig.gpe;
     import org.gvsig.andami.plugins.Extension;
     /**
      * @author <a href="mailto:jpiera@gvsig.org">Jorge Piera</a>
      */
     public class GPELibraryExtension extends Extension{
     //	private DALGPELibrary lib = null;
     	/* (non-Javadoc)
     	 * @see com.iver.andami.plugins.IExtension#execute(java.lang.String)
     	 */
     	public void execute(String actionCommand) {
     		// TODO Auto-generated method stub
+    	}
     	/* (non-Javadoc)
     	 * @see com.iver.andami.plugins.IExtension#initialize()
     	 */
     	public void initialize() {
     //		lib = new DALGPELibrary();
     //		lib.initialize();
+    	}
     	/* (non-Javadoc)
     	 * @see com.iver.andami.plugins.Extension#postInitialize()
     	 */
     	public void postInitialize() {
     //		lib.postInitialize();
+    	}
     	/* (non-Javadoc)
     	 * @see com.iver.andami.plugins.IExtension#isEnabled()
     	 */
     	public boolean isEnabled() {
     		return false;
+    	}
     	/* (non-Javadoc)
     	 * @see com.iver.andami.plugins.IExtension#isVisible()
     	 */
     	public boolean isVisible() {
     		return false;
+    	}
+    }

     /* 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.
+     *
      */
     package org.gvsig.fmap.geom.operation.writegml2;
     import org.gvsig.fmap.geom.Geometry;
     import org.gvsig.fmap.geom.operation.GeometryOperationContext;
     import org.gvsig.fmap.geom.operation.GeometryOperationException;
     import org.gvsig.fmap.geom.primitive.Surface;
     /**
      * @author gvSIG Team
      * @version $Id$
+     *
      */
     public class SurfaceWriteGml2Operation extends WriteGml2Operation{
     	public Object invoke(Geometry geom, GeometryOperationContext ctx) throws GeometryOperationException {
     	    initializeParams(ctx);
             Surface surface = (Surface)geom;
             writerHandler.startPolygon(id, new OrientablePrimitiveCoordinateSequence(surface), srs);
             writerHandler.endPolygon();
             return null;
+    	}
+    }

     /* 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.
+     *
      */
     package org.gvsig.fmap.geom.operation.writegml2;
     import org.gvsig.fmap.geom.Geometry;
     import org.gvsig.fmap.geom.operation.GeometryOperationContext;
     import org.gvsig.fmap.geom.operation.GeometryOperationException;
     import org.gvsig.fmap.geom.primitive.Point;
     /**
      * @author gvSIG Team
      * @version $Id$
+     *
      */
     public class PointWriteGml2Operation extends WriteGml2Operation{
     	public Object invoke(Geometry geom, GeometryOperationContext ctx) throws GeometryOperationException {
     	    initializeParams(ctx);
     		Point point = (Point)geom;
     		writerHandler.startPoint(id, new PointCoordinatesSequence(point), srs);
     		writerHandler.endPoint();
     		return null;
+    	}
+    }

     /* 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.
+     *
      */
     package org.gvsig.fmap.geom.operation.writegml2;
     import org.gvsig.fmap.geom.Geometry;
     import org.gvsig.fmap.geom.aggregate.MultiCurve;
     import org.gvsig.fmap.geom.operation.GeometryOperationContext;
     import org.gvsig.fmap.geom.operation.GeometryOperationException;
     /**
      * @author gvSIG Team
      * @version $Id$
+     *
      */
     public class MultiCurveWriteGml2Operation extends WriteGml2Operation{
     	public Object invoke(Geometry geom, GeometryOperationContext ctx) throws GeometryOperationException {
     	    initializeParams(ctx);
             MultiCurve multiCurve = (MultiCurve)geom;
             writerHandler.startMultiLineString(id, srs);
             for (int i=0 ; i<multiCurve.getPrimitivesNumber() ; i++){
                 writerHandler.startLineString(null, new OrientablePrimitiveCoordinateSequence(multiCurve.getCurveAt(i)), srs);
                 writerHandler.endLineString();
+            }
             writerHandler.endMultiLineString();
             return null;
+    	}
+    }

     /* 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.
+     *
      */
     package org.gvsig.fmap.geom.operation.writegml2;
     import java.io.IOException;
     import org.gvsig.fmap.geom.primitive.Point;
     import org.gvsig.gpe.lib.api.parser.ICoordinateIterator;
     import org.gvsig.gpe.lib.api.writer.ICoordinateSequence;
     /**
      * @author gvSIG Team
      * @version $Id$
+     *
      */
     public class PointCoordinatesSequence implements ICoordinateSequence, ICoordinateIterator {
         private Point point = null;
         private boolean hasNext = true;
         public PointCoordinatesSequence(Point point) {
             super();
             this.point = point;
+        }
         public int getSize() {
             return 1;
+        }
         public ICoordinateIterator iterator() {
             return this;
+        }
         public boolean hasNext() throws IOException {
             if (hasNext){
                 hasNext = false;
                 return true;
+            }
             return false;
+        }
         public int getDimension() {
             return point.getDimension();
+        }
         public void next(double[] buffer) throws IOException {
             for (int i=0 ; i<point.getDimension() ; i++){
                 buffer[i] = point.getCoordinateAt(i);
+            }
+        }
+    }

     /* 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.
+     *
      */
     package org.gvsig.fmap.geom.operation.writegml2;
     import org.gvsig.fmap.geom.GeometryLocator;
     import org.gvsig.fmap.geom.GeometryManager;
     import org.gvsig.fmap.geom.operation.GeometryOperation;
     import org.gvsig.fmap.geom.operation.GeometryOperationContext;
     import org.gvsig.gpe.lib.api.writer.IGPEWriterHandler;
     /**
      * @author gvSIG Team
      * @version $Id$
+     *
      */
     public abstract class WriteGml2Operation extends GeometryOperation {
         public static final String NAME = "writeGml2";
     	protected static GeometryManager geomManager = GeometryLocator.getGeometryManager();
         public static final int CODE = geomManager.getGeometryOperationCode(NAME);
         protected String id = null;
         protected IGPEWriterHandler writerHandler;
         protected String srs = null;
     	public int getOperationIndex() {
     		return CODE;
+    	}
     	protected void initializeParams(GeometryOperationContext geometryOperationContext){
     	    writerHandler = (IGPEWriterHandler)geometryOperationContext.getAttribute(WriteGml2OperationContext.ATTRIBUTE_GPEWRITERHANDLER);
     	    id = (String)geometryOperationContext.getAttribute(WriteGml2OperationContext.ATTRIBUTE_ID);
     	    srs = (String)geometryOperationContext.getAttribute(WriteGml2OperationContext.ATTRIBUTE_SRS);
+    	}
+    }

     /* 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.
+     *
      */
     package org.gvsig.fmap.geom.operation.writegml2;
     import java.awt.geom.PathIterator;
     import java.io.IOException;
     import org.gvsig.fmap.geom.primitive.GeneralPathX;
     import org.gvsig.fmap.geom.primitive.OrientablePrimitive;
     import org.gvsig.gpe.lib.api.parser.ICoordinateIterator;
     import org.gvsig.gpe.lib.api.writer.ICoordinateSequence;
     /**
      * @author gvSIG Team
      * @version $Id$
+     *
      */
     public class OrientablePrimitiveCoordinateSequence  implements ICoordinateSequence, ICoordinateIterator {
         private OrientablePrimitive orientablePrimitive;
         private GeneralPathX generalPathX;
         private PathIterator pathIterator;
         public OrientablePrimitiveCoordinateSequence(
             OrientablePrimitive orientablePrimitive) {
             super();
             this.orientablePrimitive = orientablePrimitive;
             this.generalPathX = orientablePrimitive.getGeneralPath();
             this.pathIterator = generalPathX.getPathIterator(null);
+        }
         public boolean hasNext() throws IOException {
            return !pathIterator.isDone();
+        }
         public int getDimension() {
             return orientablePrimitive.getDimension();
+        }
         public void next(double[] buffer) throws IOException {
             pathIterator.currentSegment(buffer);
             pathIterator.next();
+        }
         public int getSize() {
             return orientablePrimitive.getNumVertices();
+        }
         public ICoordinateIterator iterator() {
             return this;
+        }
+    }

     /* 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.
+     *
      */
     package org.gvsig.fmap.geom.operation.writegml2;
     import org.gvsig.fmap.geom.Geometry;
     import org.gvsig.fmap.geom.aggregate.MultiSurface;
     import org.gvsig.fmap.geom.operation.GeometryOperationContext;
     import org.gvsig.fmap.geom.operation.GeometryOperationException;
     /**
      * @author gvSIG Team
      * @version $Id$
+     *
      */
     public class MultiSurfaceWriteGml2Operation extends WriteGml2Operation{
     	public Object invoke(Geometry geom, GeometryOperationContext ctx) throws GeometryOperationException {
     	    initializeParams(ctx);
             MultiSurface multiSurface = (MultiSurface)geom;
             writerHandler.startMultiPolygon(id, srs);
             for (int i=0 ; i<multiSurface.getPrimitivesNumber() ; i++){
                 writerHandler.startPolygon(null, new OrientablePrimitiveCoordinateSequence(multiSurface.getSurfaceAt(i)), srs);
                 writerHandler.endPolygon();
+            }
             writerHandler.endMultiPolygon();
             return null;
+    	}
+    }

     /* 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.
+     *
      */
     package org.gvsig.fmap.geom.operation.writegml2;
     import org.gvsig.fmap.geom.Geometry;
     import org.gvsig.fmap.geom.operation.GeometryOperationContext;
     import org.gvsig.fmap.geom.operation.GeometryOperationException;
     import org.gvsig.fmap.geom.primitive.Curve;
     /**
      * @author gvSIG Team
      * @version $Id$
+     *
      */
     public class CurveWriteGml2Operation extends WriteGml2Operation{
     	public Object invoke(Geometry geom, GeometryOperationContext ctx) throws GeometryOperationException {
     	    initializeParams(ctx);
             Curve curve = (Curve)geom;
             writerHandler.startLineString(id, new OrientablePrimitiveCoordinateSequence(curve), srs);
             writerHandler.endLineString();
             return null;
+    	}
+    }

     /* 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.
+     *
      */
     package org.gvsig.fmap.geom.operation.writegml2;
     import org.gvsig.fmap.geom.Geometry;
     import org.gvsig.fmap.geom.aggregate.MultiPoint;
     import org.gvsig.fmap.geom.operation.GeometryOperationContext;
     import org.gvsig.fmap.geom.operation.GeometryOperationException;
     /**
      * @author gvSIG Team
      * @version $Id$
+     *
      */
     public class MultiPointWriteGml2Operation extends WriteGml2Operation{
     	public Object invoke(Geometry geom, GeometryOperationContext ctx) throws GeometryOperationException {
     	    initializeParams(ctx);
             MultiPoint multiPoint = (MultiPoint)geom;
             writerHandler.startMultiPoint(id, srs);
             for (int i=0 ; i<multiPoint.getPrimitivesNumber() ; i++){
                 writerHandler.startPoint(null, new PointCoordinatesSequence(multiPoint.getPointAt(i)), srs);
                 writerHandler.endPoint();
+            }
             writerHandler.endMultiPoint();
             return null;
+    	}
+    }

     /* 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.
+     *
      */
     package org.gvsig.fmap.geom.operation.writegml2;
     import org.gvsig.fmap.geom.operation.GeometryOperationContext;
     import org.gvsig.gpe.lib.api.writer.IGPEWriterHandler;
     /**
      * @author gvSIG Team
      * @version $Id$
+     *
      */
     public class WriteGml2OperationContext extends GeometryOperationContext {
     	public static final String ATTRIBUTE_GPEWRITERHANDLER = "writerHandler";
     	public static final String ATTRIBUTE_SRS = "srs";
         public static final String ATTRIBUTE_ID = "id";
         /**
          * @return the srs
          */
         public String getSrs() {
             return (String) super.getAttribute(ATTRIBUTE_SRS);
+        }
         /**
          * @param srs the srs to set
          */
         public void setSrs(String srs) {
             this.setAttribute(ATTRIBUTE_SRS, srs);
+        }
         /**
          * @return the Id
          */
         public String getId() {
             return (String) super.getAttribute(ATTRIBUTE_ID);
+        }
         /**
          * @param id the id to set
          */
         public void setId(String id) {
             this.setAttribute(ATTRIBUTE_ID, id);
+        }
         /**
          * @return the writerHandler
          */
         public IGPEWriterHandler getWriterHandler() {
             return (IGPEWriterHandler) super.getAttribute(ATTRIBUTE_GPEWRITERHANDLER);
+        }
         /**
          * @param writerHandler the writerHandler to set
          */
         public void setWriterHandler(IGPEWriterHandler writerHandler) {
             this.setAttribute(ATTRIBUTE_GPEWRITERHANDLER, writerHandler);
+        }
+    }

     /* 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):
      * 2009 {Iver T.I.}   {Task}
      */
     package org.gvsig.fmap.dal.store.gpe;
     import java.io.File;
     import java.util.Map;
     import org.cresques.cts.IProjection;
     import org.gvsig.fmap.dal.DALLocator;
     import org.gvsig.fmap.dal.DataManager;
     import org.gvsig.fmap.dal.DataServerExplorer;
     import org.gvsig.fmap.dal.DataStoreParameters;
     import org.gvsig.fmap.dal.DataTypes;
     import org.gvsig.fmap.dal.FileHelper;
     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.exception.ValidateDataParametersException;
     import org.gvsig.fmap.dal.feature.FeatureQuery;
     import org.gvsig.fmap.dal.feature.FeatureType;
     import org.gvsig.fmap.dal.feature.spi.AbstractFeatureStoreProvider;
     import org.gvsig.fmap.dal.feature.spi.FeatureProvider;
     import org.gvsig.fmap.dal.feature.spi.FeatureReferenceProviderServices;
     import org.gvsig.fmap.dal.feature.spi.FeatureSetProvider;
     import org.gvsig.fmap.dal.resource.exception.ResourceExecuteException;
     import org.gvsig.fmap.dal.resource.file.FileResource;
     import org.gvsig.fmap.dal.resource.spi.ResourceConsumer;
     import org.gvsig.fmap.dal.resource.spi.ResourceProvider;
     import org.gvsig.fmap.dal.serverexplorer.filesystem.FilesystemServerExplorer;
     import org.gvsig.fmap.dal.serverexplorer.filesystem.FilesystemServerExplorerParameters;
     import org.gvsig.fmap.dal.spi.DataStoreProviderServices;
     import org.gvsig.fmap.dal.store.gpe.handlers.FmapContentHandler;
     import org.gvsig.fmap.dal.store.gpe.handlers.FmapErrorHandler;
     import org.gvsig.fmap.geom.Geometry.TYPES;
     import org.gvsig.fmap.geom.primitive.Envelope;
     import org.gvsig.gpe.lib.api.GPELocator;
     import org.gvsig.gpe.lib.api.GPEManager;
     import org.gvsig.tools.dynobject.DynObject;
     import org.gvsig.xmlschema.lib.api.XMLSchemaLocator;
     import org.gvsig.xmlschema.lib.api.XMLSchemaManager;
     /**
      * @author <a href="mailto:jpiera@gvsig.org">Jorge Piera</a>
      */
     public class GPEStoreProvider extends AbstractFeatureStoreProvider implements
     ResourceConsumer {
         public static final String NAME = "GPE";
         public static final String DESCRIPTION = "GPE file";
         public static final String METADATA_DEFINITION_NAME = NAME;
         protected File m_Fich;
         protected boolean isOpen = false;
         //private GPEStoreParameters gpeParams;
         private ResourceProvider gpeResource;
         //Managers to manage the parsing process
         protected GPEManager gpeManager = null;
         protected XMLSchemaManager xmlSchemaManager = null;
         //The content handler and the error handler
         protected FmapContentHandler contentHandler;
         protected FmapErrorHandler errorHandler;
         public GPEStoreProvider(DataStoreParameters params,
             DataStoreProviderServices storeServices)
         throws InitializeException {
             this(params, storeServices, FileHelper
                 .newMetadataContainer(METADATA_DEFINITION_NAME));
+        }
         protected GPEStoreProvider(DataStoreParameters params,
             DataStoreProviderServices storeServices, DynObject metadata)
         throws InitializeException {
             super(params, storeServices, metadata);
             this.setDynValue("Envelope", params.getDynValue("Envelope"));
             gpeManager = GPELocator.getGPEManager();
             xmlSchemaManager = XMLSchemaLocator.getXMLSchemaManager();
             retrieveFile();
             gpeResource = this.createResource(FileResource.NAME,
                 new Object[] { m_Fich.getAbsolutePath() });
             gpeResource.addConsumer(this);
             this.initFeatureType();
+        }
         protected void retrieveFile() throws InitializeException{
             m_Fich = getGPEParameters().getFile();
+        }
         protected void initFeatureType() throws InitializeException {
             try {
                 this.open();
             } catch (DataException e) {
                 throw new InitializeException(this.getProviderName(), e);
+            }
+        }
         private GPEStoreParameters getGPEParameters() {
             return (GPEStoreParameters) this.getParameters();
+        }
         /* (non-Javadoc)
          * @see org.gvsig.fmap.dal.resource.spi.ResourceConsumer#closeResourceRequested(org.gvsig.fmap.dal.resource.spi.ResourceProvider)
          */
         public boolean closeResourceRequested(ResourceProvider resource) {
             // TODO Auto-generated method stub
             return false;
+        }
         /* (non-Javadoc)
          * @see org.gvsig.fmap.dal.resource.spi.ResourceConsumer#resourceChanged(org.gvsig.fmap.dal.resource.spi.ResourceProvider)
          */
         public void resourceChanged(ResourceProvider resource) {
             // TODO Auto-generated method stub
+        }
         /* (non-Javadoc)
          * @see org.gvsig.fmap.dal.feature.spi.FeatureStoreProvider#canWriteGeometry(int)
          */
         public boolean canWriteGeometry(int geometryType, int geometrySubtype)
         throws DataException {
             // TODO Auto-generated method stub
             return false;
+        }
         /* (non-Javadoc)
          * @see org.gvsig.fmap.dal.feature.spi.FeatureStoreProvider#createNewOID()
          */
         public Object createNewOID() {
             return contentHandler.createNewOID();
+        }
         /* (non-Javadoc)
          * @see org.gvsig.fmap.dal.feature.spi.FeatureStoreProvider#createSet(org.gvsig.fmap.dal.feature.FeatureQuery)
          */
         public FeatureSetProvider createSet(FeatureQuery query)
         throws DataException {
             return new GPESetProvider(this, query);
+        }
         protected FeatureProvider internalGetFeatureProviderByReference(
             FeatureReferenceProviderServices reference) throws DataException {
             return internalGetFeatureProviderByReference(reference,
                 this
                 .getFeatureStore()
                 .getDefaultFeatureType());
+        }
         public FeatureProvider internalGetFeatureProviderByReference(
             FeatureReferenceProviderServices reference, FeatureType featureType)
         throws DataException {
             Map featureSet = contentHandler.getFeatureSet();
             if (featureSet.containsKey(reference.getOID())){
                 return (FeatureProvider)featureSet.get(reference.getOID());
+            }
             return null;
+        }
         FeatureProvider getFeatureProviderByIndex(Long index, FeatureType fType)
         throws DataException {
             Map featureSet = contentHandler.getFeatureSet();
             if (featureSet.containsKey(index)){
                 return (FeatureProvider)featureSet.get(index);
+            }
             return null;
+        }
         public void resourcesBegin() throws ResourceExecuteException {
             // Nothing to do
+        }
         public void resourcesEnd() {
             // Nothing to do
+        }
         /* (non-Javadoc)
          * @see org.gvsig.fmap.dal.feature.spi.FeatureStoreProvider#getFeatureReferenceOIDType()
          */
         public int getOIDType() {
             return DataTypes.STRING;
+        }
         /* (non-Javadoc)
          * @see org.gvsig.fmap.dal.feature.spi.FeatureStoreProvider#getName()
          */
         public String getProviderName() {
             return NAME;
+        }
         /* (non-Javadoc)
          * @see org.gvsig.fmap.dal.spi.DataStoreProvider#getSourceId()
          */
         public Object getSourceId() {
             return getGPEParameters().getFile();
+        }
         public String getName() {
             String name = this.getGPEParameters().getFile().getName();
             int n = name.lastIndexOf(".");
             if( n<1 ) {
                 return name;
+            }
             return name.substring(0, n);
+        }
         public String getFullName() {
             return this.getGPEParameters().getFile().getAbsolutePath();
+        }
         /* (non-Javadoc)
          * @see org.gvsig.fmap.dal.spi.DataStoreProvider#open()
          */
         public void open() throws OpenException {
             if (isOpen) {
                 return;
+            }
             try {
                 errorHandler = new FmapErrorHandler();
                 contentHandler = new FmapContentHandler(errorHandler,
                     getStoreServices(), this, m_Fich,
                     getSRS(),
                     getGeometryType());
                 if (getStoreServices().getDefaultFeatureType() != null){
                     contentHandler.setFeatureType(getStoreServices().getDefaultFeatureType().getEditable());
+                }
                 contentHandler.setEnvelope((Envelope)getDynValue("Envelope"));
                 isOpen = true;
                 gpeManager.parse(contentHandler, errorHandler, m_Fich.toURI());
             } catch (Exception e) {
                 throw new OpenException("Imposible create a parser",e);
+            }
+        }
         protected IProjection getSRS(){
             return getGPEParameters().getCRS();
+        }
         protected int getGeometryType() {
             return TYPES.GEOMETRY;
+        }
         /* (non-Javadoc)
          * @see org.gvsig.fmap.dal.feature.spi.FeatureStoreProvider#createSet(org.gvsig.fmap.dal.feature.FeatureQuery, org.gvsig.fmap.dal.feature.FeatureType)
          */
         public FeatureSetProvider createSet(FeatureQuery query,
             FeatureType featureType) throws DataException {
             return new GPESetProvider(this, query, featureType);
+        }
         public long getFeatureCount() throws DataException {
             return contentHandler.getFeaturesCount();
+        }
         /* (non-Javadoc)
          * @see org.gvsig.fmap.dal.feature.spi.AbstractFeatureStoreProvider#getEnvelope()
          */
         public Envelope getEnvelope() throws DataException {
             this.open();
             return (Envelope) this.getDynValue("Envelope");
+        }
         public void setEnvelope(Envelope envelope) {
             this.setDynValue("Envelope", envelope);
+        }
         public ResourceProvider getResource() {
             return gpeResource;
+        }
         public DataServerExplorer getExplorer() throws ReadException,
         ValidateDataParametersException {
             DataManager manager = DALLocator.getDataManager();
             FilesystemServerExplorerParameters params;
             try {
                 params = (FilesystemServerExplorerParameters) manager
                 .createServerExplorerParameters(FilesystemServerExplorer.NAME);
                 params.setRoot(this.getGPEParameters().getFile().getParent());
                 return manager.createServerExplorer(params);
             } catch (DataException e) {
                 throw new ReadException(this.getProviderName(), e);
             } catch (ValidateDataParametersException e) {
                 // TODO Auto-generated catch block
                 throw new ReadException(this.getProviderName(), e);
+            }
+        }
         /**
          * @return the contentHandler
          */
         public FmapContentHandler getContentHandler() {
             return contentHandler;
+        }
         /**
          * @return the errorHandler
          */
         public FmapErrorHandler getErrorHandler() {
             return errorHandler;
+        }
+    }

     /* 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):
      * 2009 {Iver T.I.}   {Task}
      */
     package org.gvsig.fmap.dal.store.gpe;
     import java.io.File;
     import org.cresques.cts.IProjection;
     import org.gvsig.fmap.dal.DataStoreParameters;
     import org.gvsig.fmap.dal.FileHelper;
     import org.gvsig.fmap.dal.serverexplorer.filesystem.FilesystemStoreParameters;
     import org.gvsig.fmap.dal.spi.AbstractDataParameters;
     import org.gvsig.fmap.dal.spi.DataStoreProviderServices;
     import org.gvsig.fmap.geom.primitive.Envelope;
     import org.gvsig.tools.dynobject.DelegatedDynObject;
     import org.gvsig.tools.dynobject.DynStruct;
     /**
      * @author <a href="mailto:jpiera@gvsig.org">Jorge Piera</a>
      */
     public class GPEStoreParameters extends AbstractDataParameters implements
     DataStoreParameters, FilesystemStoreParameters {
         public static final String PARAMETERS_DEFINITION_NAME = "GPEStoreParameters";
         private static final String FILE_PARAMETER_NAME = "File";
         private static final String CRS_PARAMETER_NAME = "CRS";
         private static final String ENVELOPE_PARAMETER_NAME = "Envelope";
         private DelegatedDynObject parameters;
         public GPEStoreParameters() {
             this(PARAMETERS_DEFINITION_NAME);
+        }
         protected GPEStoreParameters(String parametersDefinitionName) {
             this(parametersDefinitionName, GPEStoreProvider.NAME);
+        }
         public GPEStoreParameters(String parametersDefinitionName, String name) {
             super();
             this.parameters = (DelegatedDynObject) FileHelper.newParameters(parametersDefinitionName);
             this.setDynValue(DataStoreProviderServices.PROVIDER_PARAMTER_NAME, name);
+        }
         protected static void registerParametersDefinition(){
             DynStruct dynStruct = FileHelper.registerParametersDefinition(
                 GPEStoreParameters.PARAMETERS_DEFINITION_NAME,
                 GPEStoreParameters.class, "GPEParameters.xml");
             dynStruct.addDynFieldObject("Envelope").setClassOfValue(Envelope.class).setMandatory(false);
+        }
         protected DelegatedDynObject getDelegatedDynObject() {
             return parameters;
+        }
         public String getDataStoreName() {
             return GPEStoreProvider.NAME;
+        }
         public String getDescription() {
             return GPEStoreProvider.DESCRIPTION;
+        }
         public boolean isValid() {
             return (this.getFile() != null);
+        }
         public File getFile() {
             return (File) this.getDynValue(FILE_PARAMETER_NAME);
+        }
         public void setFile(File file) {
             this.setDynValue(FILE_PARAMETER_NAME, file);
+        }
         public String getFileName() {
             return this.getFile().getAbsolutePath();
+        }
         public void setFileName(String fileName) {
             this.setDynValue(FILE_PARAMETER_NAME, fileName);
+        }
         public IProjection getCRS() {
             return (IProjection) this.getDynValue(CRS_PARAMETER_NAME);
+        }
         public void setCRS(IProjection srs) {
             this.setDynValue(CRS_PARAMETER_NAME, srs);
+        }
         public void setCRS(String srs) {
             this.setDynValue(CRS_PARAMETER_NAME, srs);
+        }
         public Envelope getEnvelope() {
             return (Envelope) this.getDynValue(ENVELOPE_PARAMETER_NAME);
+        }
         public void setEnvelope(Envelope envelope) {
             this.setDynValue(ENVELOPE_PARAMETER_NAME, envelope);
+        }
+    }

     package org.gvsig.fmap.dal.store.gpe.handlers;
     import org.gvsig.gpe.lib.impl.parser.GPEErrorHandler;
     /* gvSIG. Sistema de Informaci?n Geogr?fica de la Generalitat Valenciana
+     *
      * Copyright (C) 2004 IVER T.I. and Generalitat Valenciana.
+     *
      * 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., 59 Temple Place - Suite 330, Boston, MA  02111-1307,USA.
+     *
      * For more information, contact:
+     *
      *  Generalitat Valenciana
      *   Conselleria d'Infraestructures i Transport
      *   Av. Blasco Ib??ez, 50
      *   46010 VALENCIA
      *   SPAIN
+     *
      *      +34 963862235
      *   gvsig@gva.es
      *      www.gvsig.gva.es
+     *
      *    or
+     *
      *   IVER T.I. S.A
      *   Salamanca 50
      *   46005 Valencia
      *   Spain
+     *
      *   +34 963163400
      *   dac@iver.es
      */
     /* CVS MESSAGES:
+     *
      * $Id$
      * $Log$
+     *
      */
     /**
      * @author Jorge Piera LLodr? (jorge.piera@iver.es)
      */
     public class FmapErrorHandler extends GPEErrorHandler{
+    }

     package org.gvsig.fmap.dal.store.gpe.handlers;
     import java.io.File;
     import java.io.IOException;
     import java.util.ArrayList;
     import java.util.HashMap;
     import java.util.Iterator;
     import java.util.List;
     import java.util.Map;
     import org.cresques.cts.IProjection;
     import org.jfree.util.Log;
     import org.slf4j.Logger;
     import org.slf4j.LoggerFactory;
     import org.gvsig.fmap.dal.DataTypes;
     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.FeatureType;
     import org.gvsig.fmap.dal.feature.spi.DefaultFeatureProvider;
     import org.gvsig.fmap.dal.feature.spi.FeatureProvider;
     import org.gvsig.fmap.dal.feature.spi.FeatureStoreProviderServices;
     import org.gvsig.fmap.dal.store.gpe.GPEStoreProvider;
     import org.gvsig.fmap.dal.store.gpe.model.GPEElement;
     import org.gvsig.fmap.dal.store.gpe.model.GPEFeature;
     import org.gvsig.fmap.geom.Geometry;
     import org.gvsig.fmap.geom.Geometry.SUBTYPES;
     import org.gvsig.fmap.geom.Geometry.TYPES;
     import org.gvsig.fmap.geom.GeometryLocator;
     import org.gvsig.fmap.geom.GeometryManager;
     import org.gvsig.fmap.geom.aggregate.MultiCurve;
     import org.gvsig.fmap.geom.aggregate.MultiPoint;
     import org.gvsig.fmap.geom.aggregate.MultiPrimitive;
     import org.gvsig.fmap.geom.aggregate.MultiSurface;
     import org.gvsig.fmap.geom.exception.CreateEnvelopeException;
     import org.gvsig.fmap.geom.exception.CreateGeometryException;
     import org.gvsig.fmap.geom.primitive.Curve;
     import org.gvsig.fmap.geom.primitive.Envelope;
     import org.gvsig.fmap.geom.primitive.GeneralPathX;
     import org.gvsig.fmap.geom.primitive.Point;
     import org.gvsig.fmap.geom.primitive.Primitive;
     import org.gvsig.fmap.geom.primitive.Surface;
     import org.gvsig.gpe.lib.api.parser.IAttributesIterator;
     import org.gvsig.gpe.lib.api.parser.ICoordinateIterator;
     import org.gvsig.gpe.lib.api.parser.IGPEErrorHandler;
     import org.gvsig.gpe.lib.impl.parser.GPEContentHandler;
     /* gvSIG. Sistema de Informaci?n Geogr?fica de la Generalitat Valenciana
+     *
      * Copyright (C) 2004 IVER T.I. and Generalitat Valenciana.
+     *
      * 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., 59 Temple Place - Suite 330, Boston, MA  02111-1307,USA.
+     *
      * For more information, contact:
+     *
      *  Generalitat Valenciana
      *   Conselleria d'Infraestructures i Transport
      *   Av. Blasco Ib??ez, 50
      *   46010 VALENCIA
      *   SPAIN
+     *
      *      +34 963862235
      *   gvsig@gva.es
      *      www.gvsig.gva.es
+     *
      *    or
+     *
      *   IVER T.I. S.A
      *   Salamanca 50
      *   46005 Valencia
      *   Spain
+     *
      *   +34 963163400
      *   dac@iver.es
      */
     /* CVS MESSAGES:
+     *
      * $Id$
      * $Log$
+     *
      */
     /**
      * @author Jorge Piera LLodr? (jorge.piera@iver.es)
      */
     public class FmapContentHandler extends GPEContentHandler {
         private static final Logger LOG = LoggerFactory.getLogger(FmapContentHandler.class);
         private HashMap featureSet = null;
         private EditableFeatureType featureType = null;
         private FeatureStoreProviderServices store = null;
         private GPEStoreProvider storeProvider = null;
         private GeometryManager geomManager = GeometryLocator.getGeometryManager();
         private int featureId = 0;
         private Envelope envelope = null;
         private File file = null;
         private IProjection srs = null;
         private int geometryType = 0;
         public FmapContentHandler(IGPEErrorHandler errorHandler, FeatureStoreProviderServices store,
             GPEStoreProvider storeProvider, File file, IProjection srs, int geometryType) {
             super();
             setErrorHandler(errorHandler);
             this.store = store;
             this.storeProvider = storeProvider;
             this.file = file;
             this.srs = srs;
             this.geometryType = geometryType;
+        }
         public int getFeaturesCount(){
             return featureSet.size();
+        }
         public Feature getFeatureAt(int index){
             return (Feature)featureSet.get(new Integer(index));
+        }
         public EditableFeatureType getFeatureType(){
             return featureType;
+        }
         /**
          * @return the featureSet
          */
         public HashMap getFeatureSet() {
             return featureSet;
+        }
         /*
          * (non-Javadoc)
          * @see org.gvsig.gpe.parser.GPEContentHandler#startLayer(java.lang.String, java.lang.String, java.lang.String, java.lang.String, java.lang.String, org.gvsig.gpe.parser.IAttributesIterator, java.lang.Object, java.lang.Object)
          */
         public Object startLayer(String id, String namespace, String name,
             String description, String srs, IAttributesIterator iterator, Object parentLayer, Object box) {
             if (featureSet == null){
                 featureSet = new HashMap();
+            }
             if (envelope == null){
                 try {
                     envelope = geomManager.createEnvelope(SUBTYPES.GEOM2D);
                 } catch (CreateEnvelopeException e) {
                     Log.error("Error creating the envelope", e);
+                }
+            }
             return featureSet;
+        }
         /*
          * (non-Javadoc)
          * @see org.gvsig.gpe.IGPEContentHandler#endLayer(java.lang.Object)
          */
         public void endLayer(Object layer) {
             if (featureType == null){
                 createFeatureType(null);
+            }
             storeProvider.setEnvelope(envelope);
+        }
         /*
          * (non-Javadoc)
          * @see org.gvsig.gpe.parser.GPEContentHandler#startPoint(java.lang.String, org.gvsig.gpe.parser.ICoordinateIterator, java.lang.String)
          */
         public Object startPoint(String id, ICoordinateIterator coords, String srs) {
             return createPoint(coords);
+        }
         private Point createPoint(ICoordinateIterator coords){

| gvSIG desktop 1

Revision 38328